{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:32:22.379806300Z",
     "start_time": "2023-09-06T05:32:22.333785900Z"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium==0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 03. Prioritized Experience Replay (PER)\n",
    "\n",
    "[T. Schaul et al., \"Prioritized Experience Replay.\" arXiv preprint arXiv:1511.05952, 2015.](https://arxiv.org/pdf/1511.05952.pdf)\n",
    "\n",
    "Using a replay memory leads to design choices at two levels: which experiences to store, and which experiences to replay (and how to do so). This paper addresses only the latter: making the most effective use of the replay memory for learning, assuming that its contents are outside of our control.\n",
    "\n",
    "The central component of prioritized replay is the criterion by which the importance of each transition is measured. A reasonable approach is to use the magnitude of a transition’s TD error $\\delta$, which indicates how ‘surprising’\n",
    "or unexpected the transition is. This algorithm stores the last encountered TD error along with each transition in the replay memory. The transition with the largest absolute TD error is replayed from the memory. A Q-learning update\n",
    "is applied to this transition, which updates the weights in proportion to the TD error. One thing to note that new transitions arrive without a known TD-error, so it puts them at maximal priority in order to guarantee that all experience is seen at least once. (see *store* method)\n",
    "\n",
    "We might use 2 ideas to deal with TD-error: 1. greedy TD-error prioritization, 2. stochastic prioritization. However, greedy TD-error prioritization has a severe drawback. Greedy prioritization focuses on a small subset of the experience: errors shrink slowly, especially when using function approximation, meaning that the initially high error transitions get replayed frequently. This lack of diversity that makes the system prone to over-fitting. To overcome this issue, we will use a stochastic sampling method that interpolates between pure greedy prioritization and uniform random sampling.\n",
    "\n",
    "$$\n",
    "P(i) = \\frac{p_i^{\\alpha}}{\\sum_k p_k^{\\alpha}}\n",
    "$$\n",
    "\n",
    "where $p_i > 0$ is the priority of transition $i$. The exponent $\\alpha$ determines how much prioritization is used, with $\\alpha = 0$ corresponding to the uniform case. In practice, we use additional term $\\epsilon$ in order to guarantee all transactions can be possibly sampled: $p_i = |\\delta_i| + \\epsilon$, where $\\epsilon$ is a small positive constant.\n",
    "\n",
    "One more. Let's recall one of the main ideas of DQN. To remove correlation of observations, it uses uniformly random sampling from the replay buffer. Prioritized replay introduces bias because it doesn't sample experiences uniformly at random due to the sampling proportion correspoding to TD-error. We can correct this bias by using importance-sampling (IS) weights\n",
    "\n",
    "$$\n",
    "w_i = \\big( \\frac{1}{N} \\cdot \\frac{1}{P(i)} \\big)^\\beta\n",
    "$$\n",
    "\n",
    "that fully compensates for the non-uniform probabilities $P(i)$ if $\\beta = 1$. These weights can be folded into the Q-learning update by using $w_i\\delta_i$ instead of $\\delta_i$. In typical reinforcement learning scenarios, the unbiased nature of the updates is most important near convergence at the end of training, We therefore exploit the flexibility of annealing the amount of importance-sampling correction over time, by defining a schedule on the exponent $\\beta$ that reaches 1 only at the end of learning. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:32:23.887845900Z",
     "start_time": "2023-09-06T05:32:22.348824900Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\18213\\anaconda3\\envs\\Rainbow\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import random\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "\n",
    "if IN_COLAB and not os.path.exists(\"segment_tree.py\"):\n",
    "    # download segment tree module\n",
    "    !wget https://raw.githubusercontent.com/curt-park/rainbow-is-all-you-need/master/segment_tree.py\n",
    "        \n",
    "from segment_tree import MinSegmentTree, SumSegmentTree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:32:23.895826900Z",
     "start_time": "2023-09-06T05:32:23.864826400Z"
    }
   },
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prioritized replay Buffer\n",
    "\n",
    "The key concept of PER's implementation is *Segment Tree*. It efficiently stores and samples transitions while managing the priorities of them. We recommend you understand how it works before you move on. Here are references for you:\n",
    "\n",
    "- In Korean: https://mrsyee.github.io/rl/2019/01/25/PER-sumtree/\n",
    "- In English: https://www.geeksforgeeks.org/segment-tree-set-1-sum-of-given-range/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:32:23.896828Z",
     "start_time": "2023-09-06T05:32:23.880827700Z"
    }
   },
   "outputs": [],
   "source": [
    "class PrioritizedReplayBuffer(ReplayBuffer):\n",
    "    \"\"\"Prioritized Replay buffer.\n",
    "    \n",
    "    Attributes:\n",
    "        max_priority (float): max priority\n",
    "        tree_ptr (int): next index of tree\n",
    "        alpha (float): alpha parameter for prioritized replay buffer\n",
    "        sum_tree (SumSegmentTree): sum tree for prior\n",
    "        min_tree (MinSegmentTree): min tree for min prior to get max weight\n",
    "        \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(\n",
    "        self, \n",
    "        obs_dim: int,\n",
    "        size: int, \n",
    "        batch_size: int = 32, \n",
    "        alpha: float = 0.6\n",
    "    ):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        assert alpha >= 0\n",
    "        \n",
    "        super(PrioritizedReplayBuffer, self).__init__(obs_dim, size, batch_size)\n",
    "        self.max_priority, self.tree_ptr = 1.0, 0\n",
    "        self.alpha = alpha\n",
    "        \n",
    "        # capacity must be positive and a power of 2.\n",
    "        tree_capacity = 1\n",
    "        while tree_capacity < self.max_size:\n",
    "            tree_capacity *= 2\n",
    "\n",
    "        self.sum_tree = SumSegmentTree(tree_capacity)\n",
    "        self.min_tree = MinSegmentTree(tree_capacity)\n",
    "        \n",
    "    def store(\n",
    "        self, \n",
    "        obs: np.ndarray, \n",
    "        act: int, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool\n",
    "    ):\n",
    "        \"\"\"Store experience and priority.\"\"\"\n",
    "        super().store(obs, act, rew, next_obs, done)\n",
    "        \n",
    "        # 封装后的线段树可以当作数组进行操作\n",
    "        self.sum_tree[self.tree_ptr] = self.max_priority ** self.alpha\n",
    "        self.min_tree[self.tree_ptr] = self.max_priority ** self.alpha\n",
    "        self.tree_ptr = (self.tree_ptr + 1) % self.max_size\n",
    "\n",
    "    def sample_batch(self, beta: float = 0.4) -> Dict[str, np.ndarray]:\n",
    "        \"\"\"Sample a batch of experiences.\"\"\"\n",
    "        assert len(self) >= self.batch_size\n",
    "        assert beta > 0\n",
    "        \n",
    "        indices = self._sample_proportional()\n",
    "        \n",
    "        obs = self.obs_buf[indices]\n",
    "        next_obs = self.next_obs_buf[indices]\n",
    "        acts = self.acts_buf[indices]\n",
    "        rews = self.rews_buf[indices]\n",
    "        done = self.done_buf[indices]\n",
    "        weights = np.array([self._calculate_weight(i, beta) for i in indices])\n",
    "        \n",
    "        return dict(\n",
    "            obs=obs,\n",
    "            next_obs=next_obs,\n",
    "            acts=acts,\n",
    "            rews=rews,\n",
    "            done=done,\n",
    "            weights=weights,\n",
    "            indices=indices,\n",
    "        )\n",
    "        \n",
    "    def update_priorities(self, indices: List[int], priorities: np.ndarray):\n",
    "        \"\"\"Update priorities of sampled transitions.\"\"\"\n",
    "        assert len(indices) == len(priorities)\n",
    "\n",
    "        for idx, priority in zip(indices, priorities):  # 同步遍历两个 list 的简便写法\n",
    "            assert priority > 0\n",
    "            assert 0 <= idx < len(self)\n",
    "\n",
    "            self.sum_tree[idx] = priority ** self.alpha\n",
    "            self.min_tree[idx] = priority ** self.alpha\n",
    "\n",
    "            self.max_priority = max(self.max_priority, priority)\n",
    "            \n",
    "    def _sample_proportional(self) -> List[int]:\n",
    "        \"\"\"Sample indices based on proportions.\"\"\"\n",
    "        indices = []\n",
    "        p_total = self.sum_tree.sum(0, len(self) - 1)\n",
    "        segment = p_total / self.batch_size\n",
    "        \n",
    "        for i in range(self.batch_size):\n",
    "            a = segment * i\n",
    "            b = segment * (i + 1)\n",
    "            upperbound = random.uniform(a, b)\n",
    "            idx = self.sum_tree.retrieve(upperbound)\n",
    "            indices.append(idx)\n",
    "            \n",
    "        return indices\n",
    "    \n",
    "    def _calculate_weight(self, idx: int, beta: float):\n",
    "        \"\"\"Calculate the weight of the experience at idx.\"\"\"\n",
    "        # get max weight\n",
    "        p_min = self.min_tree.min() / self.sum_tree.sum()\n",
    "        # 这个 len(self) 是不是不需要乘\n",
    "        max_weight = (p_min * len(self)) ** (-beta)\n",
    "        \n",
    "        # calculate weights\n",
    "        p_sample = self.sum_tree[idx] / self.sum_tree.sum()\n",
    "        weight = (p_sample * len(self)) ** (-beta)\n",
    "        # 这一步的除法会把之前乘的 len(self) 消掉\n",
    "        weight = weight / max_weight\n",
    "        \n",
    "        return weight"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:32:23.908828500Z",
     "start_time": "2023-09-06T05:32:23.889829100Z"
    }
   },
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN + PER Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "\n",
    "All differences from pure DQN are noted with comments - PER.\n",
    "\n",
    "#### __init__\n",
    "\n",
    "Here, we use PrioritizedReplayBuffer, instead of ReplayBuffer, and use hold 2 more parameters beta and priority epsilon which are used to calculate weights and new priorities respectively.\n",
    "\n",
    "#### compute_dqn_loss & update_model\n",
    "\n",
    "It returns every loss per each sample for importance sampling before average. After updating the nework, it is necessary to update priorities of all sampled experiences.\n",
    "\n",
    "#### train\n",
    "\n",
    "beta linearly increases to 1 at every training step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:32:23.967880300Z",
     "start_time": "2023-09-06T05:32:23.952827700Z"
    }
   },
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "        beta (float): determines how much importance sampling is used\n",
    "        prior_eps (float): guarantees every transition can be sampled\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "        # PER parameters\n",
    "        alpha: float = 0.2,\n",
    "        beta: float = 0.6,\n",
    "        prior_eps: float = 1e-6,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "            alpha (float): determines how much prioritization is used\n",
    "            beta (float): determines how much importance sampling is used\n",
    "            prior_eps (float): guarantees every transition can be sampled\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        \n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "        \n",
    "        # PER\n",
    "        # In DQN, We used \"ReplayBuffer(obs_dim, memory_size, batch_size)\"\n",
    "        self.beta = beta\n",
    "        self.prior_eps = prior_eps\n",
    "        self.memory = PrioritizedReplayBuffer(\n",
    "            obs_dim, memory_size, batch_size, alpha\n",
    "        )\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        # PER needs beta to calculate weights\n",
    "        samples = self.memory.sample_batch(self.beta)\n",
    "        weights = torch.FloatTensor(\n",
    "            samples[\"weights\"].reshape(-1, 1)\n",
    "        ).to(self.device)\n",
    "        indices = samples[\"indices\"]\n",
    "\n",
    "        # PER: importance sampling before average\n",
    "        elementwise_loss = self._compute_dqn_loss(samples)\n",
    "        loss = torch.mean(elementwise_loss * weights)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "        \n",
    "        # PER: update priorities\n",
    "        loss_for_prior = elementwise_loss.detach().cpu().numpy()\n",
    "        new_priorities = loss_for_prior + self.prior_eps    # 避免出现零概率\n",
    "        self.memory.update_priorities(indices, new_priorities)\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "            \n",
    "            # PER: increase beta\n",
    "            fraction = min(frame_idx / num_frames, 1.0)\n",
    "            # 只有当训练结束时 beta 才会等于 1\n",
    "            self.beta = self.beta + fraction * (1.0 - self.beta)\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(\n",
    "            next_state\n",
    "        ).max(dim=1, keepdim=True)[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate element-wise dqn loss\n",
    "        elementwise_loss = F.smooth_l1_loss(curr_q_value, target, reduction=\"none\")\n",
    "\n",
    "        return elementwise_loss\n",
    "    \n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:32:23.982881500Z",
     "start_time": "2023-09-06T05:32:23.968880200Z"
    }
   },
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:32:24.002880800Z",
     "start_time": "2023-09-06T05:32:23.985881300Z"
    }
   },
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:32:24.866323700Z",
     "start_time": "2023-09-06T05:32:23.999880300Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 150\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 2000x500 with 3 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABkkAAAHBCAYAAADNUlyeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xVhf0+8OfcnT0hA0KIyFJWZFihKCqgqDjrbLVaZ3H8EK2KtoK2lX5tq1QtjipFK45aRx04UJBRVLayZCaEkQDZyU1y5/n9cc8599yVu3Nzk+f9euVVuffk5txA0uR87vN5BFEURRAREREREREREREREfUymkSfABERERERERERERERUSJwSEJERERERERERERERL0ShyRERERERERERERERNQrcUhCRERERERERERERES9EockRERERERERERERETUK3FIQkREREREREREREREvRKHJERERERERERERERE1CtxSEJERERERERERERERL0ShyRERERERERERERERNQrcUhCSePtt9/GqaeeipSUFAiCgK1btyb6lGJix44dmDVrFs444wykpaVBEAR8/fXXAY9/6623MGbMGJhMJhQXF2P27NlobW31Oa61tRWzZ89GcXExTCYTxowZg7feesvvY27evBlTp05Feno6srOzcfnll+PAgQN+j3322WcxbNgwGI1GlJWV4bHHHoPNZovoufcG+/btw/XXX48BAwYgJSUFgwYNwpw5c1BXV+dz7IEDB3D55ZcjOzsb6enpmDZtGjZv3hzSxxFFEc8884zyd1NUVIRf//rXaGhoiPVTIiIiipslS5ZAEARUVlYm+lSIiIiIOjVlyhRMmTLF4zZBEDB//vyEnA8RRY5DEkoKJ06cwPXXX49Bgwbhs88+wzfffIMhQ4Yk+rRiYuPGjfjggw+Qm5uLc889t9Njly5dimuvvRbjx4/Hp59+innz5mHJkiW4/PLLfY69/PLL8eqrr2LevHn49NNPMX78eFx77bV44403PI778ccfMWXKFFitVvz73//G4sWLsWfPHkyePBknTpzwOPaPf/wj/t//+3+4/PLL8fnnn2PWrFl44okncOedd0b/ieiBTpw4gZ/85Cf43//+h9///vdYtmwZ7rzzTvzjH//A1KlT4XQ6PY6dPHky9uzZg8WLF+Pf//43Ojo6MGXKFOzevTvox7r//vtx77334pJLLsHHH3+Mhx56CG+88QamTZvGIRYRERERERFRjC1atAiLFi1K9GkQUSyIRElg7dq1IgDx7bffDnqs2WzugjOKHYfDofz3O++8IwIQV65c6XOc3W4Xi4qKxOnTp3vcvnTpUhGAuGzZMuW2Tz75RAQgvvHGGx7HTps2TSwuLhbtdrty25VXXinm5+eLTU1Nym2VlZWiXq8XH3jgAeW22tpa0WQyibfddpvHY/7xj38UBUEQd+zYEd4T7ybsdrvY0dERl8f+xz/+IQIQv/zyS4/bn3jiCRGAuHnzZuW23/zmN6JerxcrKyuV25qamsT8/Hzxqquu6vTjHD58WNRqteLdd9/tcfsbb7whAhBfeumlGDwbIiKi+PvnP/8pAhArKioSfSpEREREYQMgzps3L9GnQURhYpKEur0bb7wRP/3pTwEAV199NQRBUOKMN954I9LT07Ft2zZMnz4dGRkZShpj+fLluOSSS9C/f3+YTCacfPLJuP3221FbW+vx+PPnz4cgCPjhhx9w5ZVXIisrC7m5uZgzZw7sdjt2796N888/HxkZGRg4cCCefPJJn3Nsbm7G/fffj7KyMhgMBvTr1w+zZ8+G2WwO+vw0mtC+DL/99ltUV1fjpptu8rj9yiuvRHp6Ot5//33ltvfffx/p6em48sorPY696aabcPToUXz33XcAALvdjo8//hhXXHEFMjMzleNKS0tx9tlnezzmZ599ho6ODp+Pf9NNN0EURXzwwQchPQ9vzz//PEaPHo309HRkZGRg2LBhePjhhz2OOXLkCG677TaUlJTAYDCguLgYP/vZz3Ds2DHlmKqqKvziF79A3759YTQaMXz4cPz1r3/1SGtUVlZCEAQ8+eST+MMf/oCysjIYjUasXLkSgCvVc/HFFyM3Nxcmkwnl5eX497//HdHzAgC9Xg8AyMrK8rg9OzsbAGAymZTb3n//fZxzzjkoLS1VbsvMzMTll1+Ojz76CHa7PeDH+fbbb+FwOHDBBRd43H7RRRcBAN59992InwMREVGiLV68GKNHj4bJZEJubi4uu+wy7Nq1y+OYAwcO4JprrkFxcTGMRiMKCgpw7rnneqxnXbFiBaZMmYK8vDykpKRgwIABuOKKK9DW1tbFz4iIiIjiYe/evbjuuus8rgv8/e9/V+7/+uuvIQgCXn/9dcyZMweFhYVISUnBWWedhS1btng8Vig/W/hbt+XP9u3bcckllyAnJ0dZh/7qq696HCOf25tvvolHHnkExcXFyMzMxNSpU322S2zZsgUXXXSR8jyLi4tx4YUX4vDhw+F/0ogIAKBL9AkQBfO73/0OEyZMwJ133oknnngCZ599tscFfavViosvvhi33347HnroIeVi8v79+3HGGWfglltuQVZWFiorK/HUU0/hpz/9KbZt26ZcwJZdddVV+MUvfoHbb78dy5cvx5NPPgmbzYYvv/wSs2bNwv3334833ngDDz74IE4++WRlxVVbWxvOOussHD58GA8//DBGjRqFHTt24NFHH8W2bdvw5ZdfQhCEqD8P27dvBwCMGjXK43a9Xo9hw4Yp98vHDh8+HDqd55e4/L7bt2/HxIkTsX//frS3t/s8pnzs8uXL0dHRAZPJpDz+yJEjPY4rKipCfn6+x8cP1VtvvYVZs2bh7rvvxl/+8hdoNBrs27cPO3fuVI45cuQIxo8fD5vNpnx+6+rq8Pnnn6OhoQEFBQU4ceIEJk6cCKvVit///vcYOHAgPv74Y9x///3Yv3+/T/z1mWeewZAhQ/CXv/wFmZmZGDx4MFauXInzzz8fp59+Ol544QVkZWXhrbfewtVXX422tjbceOONyvsPHDgQAILuS7/00ksxYMAA3HfffVi0aBFKS0uxefNm/OlPf8LMmTMxfPhwAEB7ezv279+Pyy67zOcxRo0ahfb2dhw4cCDgijmr1QoAMBqNHrfr9XplAEhERJSMFixYgIcffhjXXnstFixYgLq6OsyfPx9nnHEGNmzYgMGDBwMALrjgAjgcDjz55JMYMGAAamtrsW7dOjQ2NgJw/X/2hRdeiMmTJ2Px4sXIzs7GkSNH8Nlnn8FqtSI1NTWBz5KIiIiitXPnTkycOBEDBgzAX//6VxQWFuLzzz/HPffcg9raWsybN0859uGHH8Zpp52Gl19+GU1NTZg/fz6mTJmCLVu24KSTTgIQ/GeLUO3evRsTJ05E37598cwzzyAvLw+vv/46brzxRhw7dgwPPPCAx/EPP/wwJk2ahJdffhnNzc148MEHMXPmTOzatQtarRZmsxnTpk1DWVkZ/v73v6OgoAA1NTVYuXIlWlpaov48EvVaiY6yEIVi5cqVIgDxnXfe8bj9l7/8pQhAXLx4cafv73Q6RZvNJh48eFAEIP73v/9V7ps3b54IQPzrX//q8T5jxowRAYjvvfeecpvNZhP79OkjXn755cptCxYsEDUajbhhwwaP9//Pf/7jswYrmM7Wbf3xj38UAYjV1dU+902fPl0cMmSI8ufBgweL5513ns9xR48eFQGITzzxhCiKovi///1PBCC++eabPsfKK6GOHj0qiqIo3nrrraLRaPR73kOGDPFZAxaKu+66S8zOzu70mF/96leiXq8Xd+7cGfCYhx56SAQgfvfddx63//rXvxYFQRB3794tiqIoVlRUiADEQYMGiVar1ePYYcOGieXl5aLNZvO4/aKLLhKLioo81qINGjRIHDRoUEjP8ejRo+IZZ5whAlDerrzySo8VX0eOHBEBiAsWLPB5f3ll1rp16wJ+jK1bt4oAxN///vcet3/11VciANFgMIR0rkRERImmXrfV0NAgpqSkiBdccIHHMVVVVaLRaBSvu+46URRdK0EBiAsXLgz4uPLPZVu3bo3r+RMREVFinHfeeWL//v09VomLouu6g8lkEuvr65VrS6eddprodDqVY+SV47fccosoiqH9bCGKonjWWWeJZ511lsdt8Fq3dc0114hGo1GsqqryOG7GjBliamqq2NjYKIqi+7qX9889//73v0UA4jfffCOKoihu3LhRBCB+8MEHwT8pRBQyrtuiHuGKK67wue348eO44447UFJSAp1OB71er6wy8l7RALhXE8mGDx8OQRAwY8YM5TadToeTTz4ZBw8eVG77+OOPMWLECIwZMwZ2u115O++88yAIAr7++usYPUuXQKkU79s7S69Eemw4jxmKCRMmoLGxEddeey3++9//+qxCA4BPP/0UZ599tpK68GfFihU45ZRTMGHCBI/bb7zxRoiiiBUrVnjcfvHFF3skifbt24cff/wRP//5zwHA4+/xggsuQHV1tUe8dd++fdi3b1/Q59fQ0IBLLrkEzc3NWLp0KVavXo1FixZh7dq1uPjii31WaEX6+R09ejTOPPNM/PnPf8Y777yDxsZGrFu3DnfccQe0Wm3IK92IiIi6k2+++Qbt7e0eaU4AKCkpwTnnnIOvvvoKAJCbm4tBgwbhz3/+M5566ils2bLFY90mAIwZMwYGgwG33XYbXn31VRw4cKCrngYRERHFWUdHB7766itcdtllSE1N9fmdvqOjA99++61y/HXXXefxO3ZpaSkmTpyorOIO5WeLUK1YsQLnnnsuSkpKPG6/8cYb0dbWhm+++cbj9osvvtjjz/LmD/k61Mknn4ycnBw8+OCDeOGFFzw2cRBR5HjljJJeamqqx/otAHA6nZg+fTree+89PPDAA/jqq6+wfv165f8U29vbfR4nNzfX488GgwGpqakevRHy7R0dHcqfjx07hh9++AF6vd7jLSMjA6Io+r3wH4m8vDwAQF1dnc999fX1Huefl5cX8DjA/VyDPaYgCEp/Rl5eHjo6Ovzu7fb++KG6/vrrsXjxYhw8eBBXXHEF+vbti9NPPx3Lly9Xjjlx4gT69+/f6ePU1dWhqKjI5/bi4mLlfjXvY+Vuk/vvv9/n73HWrFkAENHf4//93/9h69atWL58Oa677jpMnjwZv/71r7F06VJ88cUXWLp0KQAgJycHgiCE9HcWyDvvvINJkybhqquuQk5ODs4++2xcfvnlGDNmDPr16xf2uRMRESWa/P+Lgf4/Xr5fEAR89dVXOO+88/Dkk0/itNNOQ58+fXDPPfcoaycGDRqEL7/8En379sWdd96JQYMGYdCgQfjb3/7WdU+IiIiI4qKurg52ux3PPvusz+/0cnen+nf6wsJCn8coLCwM62eLcM4tnOsV8nUambxWW76OlZWVhVWrVmHMmDF4+OGHceqpp6K4uBjz5s2DzWYL69yIyI2dJJT0/L3Cfvv27fj++++xZMkS/PKXv1RuD+XV/+HKz89HSkoKFi9eHPD+WJC7QLZt24ZTTjlFud1ut+PHH3/Etdde63Hsm2++Cbvd7tFLsm3bNgDAiBEjALguGKSkpCi3q23btg0nn3yyMiRSf/zTTz9dOa6mpga1tbXKY4brpptuwk033QSz2YzVq1dj3rx5uOiii7Bnzx6UlpaiT58+QcvH8vLyUF1d7XP70aNHAfj+HXj/m5Hvnzt3rtI1423o0KEhPyfZ1q1b0a9fP58fiMaPHw/A3TOTkpKCk08+OeDfQ0pKirIXNZC+ffti2bJlOH78OGpqalBaWoqUlBQsWrQIP/vZz8I+dyIiokSTLxIE+v949f+/l5aW4pVXXgEA7NmzB//+978xf/58WK1WvPDCCwCAyZMnY/LkyXA4HNi4cSOeffZZzJ49GwUFBbjmmmu64BkRERFRPOTk5ECr1eL666/HnXfe6feYsrIy5Xfumpoan/tramo8BhSh/GwRinCvV4Ri5MiReOuttyCKIn744QcsWbIEjz/+OFJSUvDQQw+F/XhExCQJ9VDyRXDvIusXX3wx5h/roosuwv79+5GXl4dx48b5vMkl39E6/fTTUVRUhCVLlnjc/p///Aetra0eF/cvu+wytLa24t133/U49tVXX0VxcbEy5NDpdJg5cybee+89j1dDVFVVYeXKlR6Pef7558NkMvl8/CVLlkAQBFx66aVRPb+0tDTMmDEDjzzyCKxWK3bs2AEAmDFjBlauXOmx7srbueeei507d2Lz5s0et7/22msQBAFnn312px976NChGDx4ML7//nu/f4fjxo1DRkZG2M+puLgYhw8fxpEjRzxul+O06oTMZZddhhUrVuDQoUPKbS0tLXjvvfdw8cUXewy7OtO3b1+MGjUKWVlZeOGFF2A2m3HXXXeFfe5ERESJdsYZZyAlJQWvv/66x+2HDx9WVlf4M2TIEPz2t7/FyJEjfX42AACtVovTTz8df//73wHA7zFERESUPFJTU3H22Wdjy5YtGDVqlN/f6dUDkDfffBOiKCp/PnjwINatW4cpU6b4ffxgP1t05txzz8WKFSuUoYjstddeQ2pqKn7yk5+E9XhqgiBg9OjRePrpp5Gdnc2faYiiwCQJ9UjDhg3DoEGD8NBDD0EUReTm5uKjjz7yWOMUK7Nnz8a7776LM888E/feey9GjRoFp9OJqqoqfPHFF7jvvvs8khfe2trasGzZMgBQ1oGtWrUKtbW1yuAAcP1C/+STT+L666/H7bffjmuvvRZ79+7FAw88gGnTpuH8889XHnPGjBmYNm0afv3rX6O5uRknn3wy3nzzTXz22Wd4/fXXodVqlWMfe+wxjB8/HhdddBEeeughdHR04NFHH0V+fj7uu+8+5bjc3Fz89re/xe9+9zvk5uZi+vTp2LBhA+bPn49bbrnFI93y2muv4Ve/+hUWL16MG264IeBzv/XWW5GSkoJJkyahqKgINTU1WLBgAbKyspS0xeOPP45PP/0UZ555Jh5++GGMHDkSjY2N+OyzzzBnzhwMGzYM9957L1577TVceOGFePzxx1FaWopPPvkEixYtwq9//WsMGTIk6N/jiy++iBkzZuC8887DjTfeiH79+qG+vh67du3C5s2b8c477yjHnnzyyQCCJ5PuvPNOLF26FNOmTcNDDz2EkpISbN++HX/4wx9QUFCgdKAArlVf//rXv5TnYDQa8ac//QkdHR2YP3++x+P6+/j/+Mc/ALjSQY2Njfj000/xyiuv4IknnsBpp50W9PkTERF1N9nZ2fjd736Hhx9+GDfccAOuvfZa1NXV4bHHHoPJZMK8efMAAD/88APuuusuXHnllRg8eDAMBgNWrFiBH374QXk15QsvvIAVK1bgwgsvxIABA9DR0aGkgKdOnZqw50hERESx8be//Q0//elPlTXXAwcOREtLC/bt24ePPvrIo6v0+PHjuOyyy3DrrbeiqakJ8+bNg8lkwty5cwGE9rNFqObNm4ePP/4YZ599Nh599FHk5uZi6dKl+OSTT/Dkk08iKysrrMf7+OOPsWjRIlx66aU46aSTIIoi3nvvPTQ2NmLatGlhPRYRqSSyNZ4oVCtXrhQBiO+8847H7b/85S/FtLQ0v++zc+dOcdq0aWJGRoaYk5MjXnnllWJVVZUIQJw3b55y3Lx580QA4okTJ0J67LPOOks89dRTPW5rbW0Vf/vb34pDhw4VDQaDmJWVJY4cOVK89957xZqamk6fW0VFhQjA71tpaanP8W+88YY4atQo0WAwiIWFheI999wjtrS0+BzX0tIi3nPPPWJhYaFoMBjEUaNGiW+++abfc9i4caN47rnniqmpqWJmZqZ46aWXivv27fN77N/+9jdxyJAhosFgEAcMGCDOmzdPtFqtHsf885//FAGI//znPzt97q+++qp49tlniwUFBaLBYBCLi4vFq666Svzhhx88jjt06JD4q1/9SiwsLBT1er1y3LFjx5RjDh48KF533XViXl6eqNfrxaFDh4p//vOfRYfDoRwjf67//Oc/+z2f77//XrzqqqvEvn37inq9XiwsLBTPOecc8YUXXvA4rrS01O/fjT+bN28WL7vsMrF///6i0WgUTzrpJPGWW24Rq6qqfI7dt2+feOmll4qZmZliamqqeO6554qbNm3yOc7fx3/xxRfF4cOHi6mpqWJ6ero4efJk8YMPPgjpHImIiLoL+WeIiooK5baXX35Z+dknKytLvOSSS8QdO3Yo9x87dky88cYbxWHDholpaWlienq6OGrUKPHpp58W7Xa7KIqi+M0334iXXXaZWFpaKhqNRjEvL08866yzxA8//LCrnyIRERHFSUVFhfirX/1K7Nevn6jX68U+ffqIEydOFP/whz+Ioui+tvSvf/1LvOeee8Q+ffqIRqNRnDx5srhx40blcUL52UIUXdeHzjrrLI9z8L7mJIqiuG3bNnHmzJliVlaWaDAYxNGjR/tcLwl03Uu+jiEf/+OPP4rXXnutOGjQIDElJUXMysoSJ0yYIC5ZsiS6Tx5RLyeIoipfRkRERERERERERNTDfP311zj77LPxzjvvsLuTiDywk4SIiIiIiIiIiIiIiHolDkmIiIiIiIiIiIiIiKhX4rotIiIiIiIiIiIiIiLqlZgkISIiIiIiIiIiIiKiXolDEiIiIiIiIiIiIiIi6pU4JCEiIiIiIiIiIiIiol5Jl+gTiITT6cTRo0eRkZEBQRASfTpERETdgiiKaGlpQXFxMTQavg4invizCBERkS/+LNJ1+LMIERGRr0h/FknKIcnRo0dRUlKS6NMgIiLqlg4dOoT+/fsn+jR6NP4sQkREFBh/Fok//ixCREQUWLg/iyTlkCQjIwOA68lmZmYm+GyIiIi6h+bmZpSUlCj/P0nxw59FiIiIfPFnka7Dn0WIiIh8RfqzSFIOSeQoaWZmJn8YICIi8sKVC/HHn0WIiIgC488i8cefRYiIiAIL92cRLgklIiIiIiIiIiIiIqJeiUMSIiIiIiIiIiIiIiLqlTgkISIiIiIiIiIiIiKiXolDEiIiIiIiIiIiIiIi6pU4JCEiIiIiIiIiIiIiol6JQxIiIiIiIiIiIiIiIuqVOCQhIiIiIiIiIiIiIqJeiUMSIiIiIiIiIiIiIiLqlTgkISIiIiIiIiIiIiKiXolDEiIiIiIiIiIiIiIi6pXCGpIsWLAA48ePR0ZGBvr27YtLL70Uu3fv9jhGFEXMnz8fxcXFSElJwZQpU7Bjxw6PYywWC+6++27k5+cjLS0NF198MQ4fPhz9syEiIiIiIiIi6kKrV6/GzJkzUVxcDEEQ8MEHHwR9n1WrVmHs2LEwmUw46aST8MILL8T/RImIiMivsIYkq1atwp133olvv/0Wy5cvh91ux/Tp02E2m5VjnnzySTz11FN47rnnsGHDBhQWFmLatGloaWlRjpk9ezbef/99vPXWW1i7di1aW1tx0UUXweFwxO6ZERERERERERHFmdlsxujRo/Hcc8+FdHxFRQUuuOACTJ48GVu2bMHDDz+Me+65B++++26cz5SIiIj8EURRFCN95xMnTqBv375YtWoVzjzzTIiiiOLiYsyePRsPPvggAFdqpKCgAP/3f/+H22+/HU1NTejTpw/+9a9/4eqrrwYAHD16FCUlJVi2bBnOO++8oB+3ubkZWVlZaGpqQmZmZqSnT0RE1KPw/x+7Dj/XREREvvj/j4AgCHj//fdx6aWXBjzmwQcfxIcffohdu3Ypt91xxx34/vvv8c0334T0cfi5JiIi8hXp/z/qovmgTU1NAIDc3FwArldD1NTUYPr06coxRqMRZ511FtatW4fbb78dmzZtgs1m8zimuLgYI0aMwLp160IakhBR6GwOJw7WmTGoTzoEQQj7/a12JzZXNcDuCDxPzU7VY0S/rGhOU2G22HGixYKB+Wl+72+12NFgtqIkNzWix29qt2Hb4SaP28r6pKFfdkpEj1fXaoHNIaIwyxTR+xMRyb47UAebQ0T5gGykGaP6EY2IiIi6sW+++cbjmggAnHfeeXjllVdgs9mg1+u7/JxEUcSh+nZsqKzHpeX9oNWE/7sjERFRsor4N3BRFDFnzhz89Kc/xYgRIwAANTU1AICCggKPYwsKCnDw4EHlGIPBgJycHJ9j5Pf3ZrFYYLFYlD83NzdHetpEvc6Tn/2If6ypwMs3jMPUUwqCv4OXeR9ux5vrDwU97i9XjsbPxvaP5BQ9zFq6Gav3nsBXc87CSX3Sfe6/9dWN+K6iDmsePCeiwcbPX/4W2494fg8x6jRY//BUZKWG98uIKIq4+Ln/oaXDhm/mnsuLmkQUlVlLN6PObMUX956JIQUZiT4dIiIiipOamhq/103sdjtqa2tRVFTk8z7xvi7iFIELn1mDFosdQwszYvYiOCIiomQQVieJ2l133YUffvgBb775ps993q9WF0Ux6CvYOztmwYIFyMrKUt5KSkoiPW2iXufHGlcfUEWtOciR/lXVtwEAirNMGFaY4fM2MM+V6Hj0v9tRGeHH8DzfZogisOdYq9/7d9U0wykCh6XzCte+467HHdQnDcMKM6DVCLDYnTjW0hH2Y9kcIo40tqO5w47dx1qCvwMRERERERH8Xzfxd7ss3tdFtBoBp5W6Xsy6obI+po9NRETU3UU0JLn77rvx4YcfYuXKlejf3/3K8cLCQgDwSYQcP35ceZVEYWEhrFYrGhoaAh7jbe7cuWhqalLeDh0K/qp2InJpbLMBANqsjojeX16z9ciFp+Cz2Wf6vH113xScXpaLNqsD/++tLbA5nBGfqyiKqGu1AgDqzVY/5+JUno/FHv7HsTuc6LC53u+dOybis9lnom+G0fV4tvAfr93m/pzu5ZCEiGIk8rY4IiIiSgaFhYV+r5vodDrk5eX5fZ+uuC4yocy1Sp1DEiIi6m3CGpKIooi77roL7733HlasWIGysjKP+8vKylBYWIjly5crt1mtVqxatQoTJ04EAIwdOxZ6vd7jmOrqamzfvl05xpvRaERmZqbHGxGFpqHNNWxos9kjen+H03W1LtBOWq1GwNNXj0GmSYfvDzfh6eV7IjtRuPpC7NLHqzdbfO5vkAYkgKsrJVxm1aAozagF4Fq1BQBWR/hDpA6PIYn/5AsRUagiqI0iIiKiJHTGGWd4XBMBgC+++ALjxo0L2EfSFddFxg90DUnWVzQoyRYiIqLeIKwhyZ133onXX38db7zxBjIyMlBTU4Oamhq0t7cDcMVCZ8+ejSeeeALvv/8+tm/fjhtvvBGpqam47rrrAABZWVm4+eabcd999+Grr77Cli1b8Itf/AIjR47E1KlTY/8MiXo5OXnRHmmSRBpa6Dop7ivOTsGfrhgFAHh+1X58s78uoo9V22r1+9+yOtXgJJIkidniGhTptQKMOteQxCANSSJKkqg+p3uOc0hCRERERNQbtba2YuvWrdi6dSsAoKKiAlu3bkVVVRUAVwrkhhtuUI6/4447cPDgQcyZMwe7du3C4sWL8corr+D+++9PxOkrRvXPgkGrQW2rBZV1ka03JiIiSkZhDUmef/55NDU1YcqUKSgqKlLe3n77beWYBx54ALNnz8asWbMwbtw4HDlyBF988QUyMtwFpE8//TQuvfRSXHXVVZg0aRJSU1Px0UcfQavVxu6ZERGsdidapcGA2RLZkERJkmg7f4nzBSOLcPW4EogicO/bW9HcYev0eH/qWt1DEH/rtupVg5NIkh/y50JdsC4PSywRrAnrsLvPYR/XbRERERER9UobN25EeXk5ysvLAQBz5sxBeXk5Hn30UQCu7RnywARwbeFYtmwZvv76a4wZMwa///3v8cwzz+CKK65IyPnLTHotRpe4Cts3VHDlFhER9R664Ie4hRK3FAQB8+fPx/z58wMeYzKZ8Oyzz+LZZ58N58MTUZga291DhfYI122FkiSRzbv4FKzdV4sjje34Zn8dzju1MKyPVacajPgbkqjvjyT5oQxJDO5vfbFKkhxt6kBLhw0ZJv/xeCKiUIngegsiIqJkMmXKlE6vlyxZssTntrPOOgubN2+O41lFZtzAXGyobMCGynpcNT625fBERETdVUTF7USUHBpVHR6RFrc7nK7hQaBOErVUgw5DCtIBAM3t0SVJ6vwlSczqJEnk67YyTKohiVbuJImuuB0A9nHlFhFFhaUkRERElFgTBrK8nYiIeh8OSYh6sAbVUCHSIYk7SRLatwt5lZWc2giHuofEX3F7tEkSs791W3o5SRJdcTsA7OWQhIiIiIiIkthppTkQBKCyrg3HWzoSfTpERERdgkMSoh6sQZUkibS4XekkCSFJArhTGq0d4Q9J1MXs9WarT2RdPTiJJPnRKvWyqIckUSVJrJ7vs5e9JEQUAyFsNyUiIiKKi6wUPYYVZgIANlQ0JPhsiIiIugaHJEQ9WGObOkkSYSeJI/ROEgBIjyJJUqdKktgcIpq9Bi3q+y32yJMk6UatcptR7/pvawSP571ui0kSIoqGwG1bRERE1A1MGJgDgCu3iIio9+CQhKgHS0SSJN3oKi5viXJIAviWt3us27KH/3z8FrdLSZJIhi7yuq28NAMAYO8xDkmIiIiIiCi5jS9z9ZKsr+CQhIiIegcOSYh6MI8kSQSdG4C7kyTUIUmalNIwR9JJ4tVD4t1L4lHcHkWSxF8nSSSPJw9JRvbPAgAcaWyPKEFDRKTGdVtERESUSOOl8vZdNc1o7rAFOZqIiCj5cUhC1IM1tEVf3O5wuoYHoa7biqqTREqSZEhDjM6SJdGt2/KXJAn/8yOnc4qyTMhPNwIA9nPlFhFFiNu2iIiIqDsoyDRhQG4qRBHYfJC9JERE1PNxSELUg6nXbVntTmV1VjjCTZJEum7Laneiqd11voML0gF4rtdyOEWPoU8kyY+WGCdJ5E4Sk16LIdI572F5OxERERERJTk5TcJeEiIi6g04JCHqwdTrtoDIytvlwYpOE9q3i/QIkyTyAESrEXBSH9fAQZ0caWizeqygiVlxexSdJPKQJEWvxeC+rnPexyQJEUVJBPdtERERUWJNKJPK2yuYJCEiop6PQxKiHkydJAEiK29Xitu1oSZJpE6SMAcyta2u/pHcNAPy0l1F6Op1W94l7tYI1mOZLa73kQc5AGDQRd9JkqLX4uSCDABMkhBR5ATu2yIiIqJuQk6SbD3cGNFqYiIiomTCIQlRD+abJIl8SBJqJ4m8bivcJIk8EMlLMyAvzTUkURe3e/eTRJL8kEvV0wyqdVs6bcSPJw+dUgxaDJGSJHuZJCEiIiIioiRXlp+G/HQDrHYnfjjclOjTISIiiisOSYh6KFEU0SglSeRXJ4c7JBFFMfxOEimlEW4nSZ00EMlPNyI3zSjd1lmSJEbF7VElSVzvY9JrMVhKkhxuaFc+DhFRJERu2yIiIqIEEwRBSZOsr2AvCRER9WwckhD1UC0WuzLg6JPuGjq028K7eK/ueQ89SeIaQFjtzrAGD0qSJN2dJPFct+UaosjDmmg6STyK23XRd5KY9FrXmjDpvPefYJqEiIiIiIiS2ziWtxMRUS/BIQlRD9VodqVITHoNcqWL9+EmSexO9+Ag5CSJagARTqKiVlm3ZVQ6SdTpETlVUpDhGvhEkvxo9TMkMShDkvBXkamL2wFgcIG0cusYhyREFD4BLCUhIiKi7mOCNCTZdLBBWcNMRETUE3FIQtRDNUh9JDmpBqQYXBfxwx2SqH8Q1mlC+3ah1QjK0KA1jCFJnVTcnpduUIY69WYrRGnvjJwqKcpOARD+kEQURZil559u9O0kiaq43eD63AzuK5W3H2d5OxERERERJbfhRRlIM2jR0mHH7hr+jkNERD0XhyREPZQ8JMlONSBVGpK0h50kcQ9JQk2SAKpekjDK2+WkSH66AXlSJ4nV4VQGLXKqpCjLBCD85IfF7lSGPmlGrXK7IZp1W1b3ui3AnSTZxyQJERERERElOZ1Wg9NKcwBw5RYREfVsHJIQ9VByaXtOqh4petfQIuwkiUOdJAl9SJIhJTUiSpKkGZFi0CppFDlBIhe7y0OScJMf6oFNmsG3kySSJInPui0pSfJjTQu2H2lS3lo6bGE/NhH1PgK3bREREVE3I6/cWs8hCRER9WC64IcQUTJSr9uSUyBt1vCK2+UkiSAAmgiSJK2W0IcDtaridgDITTPgSGM76sxWDMxPU5IkhVmudVvhJj/kfpRUg9bjuUTTSdJhc52DvM5MTpIcaWzHRc+uVY7rm2HEmgfPVlZ7ERERERERJYPxZVJ5e0U9RFGEwFd1EBFRD8QkCVEP1SAlSbJT9RGv25LXU4WTIgHcSY1WS2gfTxRFJSmSn26U/tezvF3+3+IIkyRyqkXdRwK4hyRWR+SdJCZp+JGfbsTV40pQkGlU3rQaAcdbLNzhS0QhE9mLSkRERN3EmJJs6LWu32mq6tsSfTpERERxwSQJUQ/VqEqSmKUESZst3E4S1+AgnD4SQJUkCbGTxGx1KKkMdZIEAOrNFjidoruTJDu6JIn3kERet2WxhV8Er6zbMrgTIv/3s1Eex13/yndYs7cW2480Y1T/7LA+BhH1LnxdJhEREXU3Jr0WI/tlYXNVI9ZX1KM0Ly3Rp0RERBRzTJIQ9VCxTZKE963C3UkS2rotuY8kRa9FqpRCyZXK2+vMVjS22yB3yBdmSkkShxNiGC+3lgdFaQGGJOEmSWwOUfn8yMXt/ozolwUA2H60KazHJyIiIiIi6g7klVsbKxsSfCZERETxwSEJUQ+lTpLIg4dIO0nCDJKEnSTx7iNR/3ddqxX10iquTJMOaUb3QCKcNIm8+kv9/gCUnpBwkyTtqlROSmdDkmLXkGTHEQ5JiCg0Irhvi4iIiLoPubx9A8vbiYioh+KQhKiHUorb0/TKRfy2SJMk2vC+VaQZw+skkZMkeVIfCaBet2VFnTJEMSodIkB46Y9A67Yi7SSR+0i0GgF6beAp0oh+mQCAXTUtsEXQe0JEvQeLUImIiKg7GleaC0EADtSacaLFkujTISIiijkOSYh6qAazvG7LEPG6LbvDNSQJu5Mk3HVbUt9IfpoqSSL9d53ZqvSR5KYZYFANbMJJf8hDkkDrthxOEfYwhhjykCRFr+30wuaA3FRkmHSw2p3Yd7w15McnIiIiIiLqDrJS9RhakAEA2Mg0CRER9UAckhD1UOp1W3KxeMRJkjCHJBnyui1LaOu23EkS33Vb9WaLMkTJTTNAEISI0h+tAYYkkSZT5HVbJn3n30YFQcCpxa40yXavlVuiKOKpL3bj7yv3hfxxiajnC6NuiYiIiKhLjJdWbq3nkISIiHogDkmIeiCr3QmzNBDJSdW7O0lsYQ5JxOiSJC1hd5Ko1225/ru+1b1uK18anChl6+F0knQEWLelSqaE83hyKqez0naZ3EviPST5saYFz6zYhz9/vhtNbaGlboiIiIiIiLrauIE5ANhLQkREPROHJEQ9kJwi0QhApkmvWrcVXnG7w+kaGoSbJHGv2woxSSIlRfL8rNuqNbuL2+WeEnlIYrGHPvQxS889zeA5JNFpNcoQKJwi+HbVuq1gRvSThiRHmz1uX77zmPLfhxvbQv7YREREREREXWlCmStJsvNoc8i/5xERESULDkmIeqAGKZWQlaKHRiMoQ5Jw121F20liDnPdVr6f4nar3YlDDe3Sba775fRHWEkSqUQ+3aTzuS+Sx1M6SQyhDElc67Z2Hm1WVpgBwJe73EOSo40dIX9sIurZuG2LiIiIupuirBT0z0mBUwQ2H2xI9OkQERHFFIckRD1Qg6qPBICybivc4nZ3J0l43yrkQURriOu26pR1W+4kSapBq/R97D3e4rpfTpJI6Y1wkh/ywCbd6DvUMOrDT6a0W10fO5R1W2X56Ug1aNFuc6Ci1lXeXtPUgR8Ou9dvHWlgkoSIiIiIiLqvCVIvCVduERFRT8MhCVEPJK/byk7VA0DkSRJnlJ0kIa/bkorb09xJEkEQlD8fqpeTJK4hSWRJEv/F7erHi9e6La1GwClFcnm7a+XWclWKBACONjFJQhSNRYsWoaysDCaTCWPHjsWaNWsCHvv1119DEASftx9//LELz9iXEN63WiIiIqIuNV5aubW+gkMSIiLqWTgkIeqB5HVbcpJEXgnVbnPA6Qx9kYuSJNGGOSQxuddtiWLnH8/hFFFv9ixml+Wm+f9zJMkPcydDEvfjhb9uS067BKP0kkjl7XIfSVGWCQBwRFopRkThe/vttzF79mw88sgj2LJlCyZPnowZM2agqqqq0/fbvXs3qqurlbfBgwd30RkTERERJZ/xUpJk66HGsH4XIyIi6u44JCHqgRqUJIm8bsuddugI44fZaJMkTtGduAiksc0KeW6TE2AoIpM7SyJJkrjXbcW4kySEJAkAnFosJUmONqGlw4Zv9tcCAH7xk1IAwOFGDkmIIvXUU0/h5ptvxi233ILhw4dj4cKFKCkpwfPPP9/p+/Xt2xeFhYXKm1Yb2tdzvAUbLhMRERElwqA+achNM8Bidyov/iIiIuoJOCQh6oEalSSJa92WSee+8BfOyi2H0zU00IU5JEnRayG/S7BekjqzezWYXuv5LSnPa0iSk+Z6PpEkP+Ti9jSDnySJ9PkJZ0gi97uEUtwOuJMkO440Y9WeE7A5RJTlp+HMwX0AAEc5JCGKiNVqxaZNmzB9+nSP26dPn45169Z1+r7l5eUoKirCueeei5UrV3Z6rMViQXNzs8dbrHHdFhEREXVngiBgXGkOAGB9BcvbiYio5+CQhKgHapAGD3IyQ6MRlMRDOOXtkSZJBEEIuZektlXuIzH43Kcucs8w6pRhRiQdIp0mSXSRd5KEUtwOACf3TYdBp0GLxY5X1lYAAKYO74t+OSkAgBMtFiWdQkShq62thcPhQEFBgcftBQUFqKmp8fs+RUVFeOmll/Duu+/ivffew9ChQ3Huuedi9erVAT/OggULkJWVpbyVlJTE9HkQERERJYMJUi/JRpa3ExFRD+J7tZCIkp7cSSIXtwOulVvtNkeYSRKpk0QT/jw1w6RHc4c9eJKk1TXQyUs3+tyXqypyz1UNTMJNftgdTmWokWb0HWrIQ5KwkiRhrtvSazUYXpiB7w83YUtVIwBg2imFyEnVI0Xv+rupaerAwPy0kM+BiNwErxiGKIo+t8mGDh2KoUOHKn8+44wzcOjQIfzlL3/BmWee6fd95s6dizlz5ih/bm5ujtughMu2iIiIqLuSe0k2HmyA0ylCE+YL6oiIiLojJkmIeqBGqZNELm4H3Guh2qydDy3U7I7IkiSAexhhDpIkqZOSJN6l7YBnukTdTxJu8sOsGgzJpfJqRl34RfDhdpIAwKnSyi3A9XzGluZAEAQUZ0vl7Vy5RRS2/Px8aLVan9TI8ePHfdIlnfnJT36CvXv3BrzfaDQiMzPT4y3WBPAiAxEREXVvpxZnItWgRVO7DXuOtyT6dIiIiGIi7CHJ6tWrMXPmTBQXF0MQBHzwwQce9wuC4Pftz3/+s3LMlClTfO6/5ppron4yROTiLm73TJIA4a3bckS4bgtAyOu25E6SvDR/SRL3YCTPz5Ak1OSHPKjRawUlhaJmjCBJ0mFzHRvqui0AGFHsHpKcM6yv8nntl5MKADjSwCEJUbgMBgPGjh2L5cuXe9y+fPlyTJw4MeTH2bJlC4qKimJ9ekREREQ9ik6rwWkDXL0kGyq4couIiHqGsIckZrMZo0ePxnPPPef3/urqao+3xYsXQxAEXHHFFR7H3XrrrR7Hvfjii5E9AyLy4S5uVydJXEML73VbK348hl8uXo+apg6fx4m0kwQA0k2uAU2wdVu1yrot3ySJesWWeogSbvJDHpKk+ekjcT2eVnq88IvbTSEWtwPAiH7uV55PHe5+hXs/JkmIojJnzhy8/PLLWLx4MXbt2oV7770XVVVVuOOOOwC4VmXdcMMNyvELFy7EBx98gL1792LHjh2YO3cu3n33Xdx1112JegoeRO7bIiIiom5MXrm1vpLl7URE1DOE3UkyY8YMzJgxI+D9hYWFHn/+73//i7PPPhsnnXSSx+2pqak+xxJR9ERRRGO775AkVUo8tHmVg//zf5VYs7cWq/Ycx9XjB3jc53C6hga6CIYkGdJAojXEdVv+OknyA3SShJskkc8hzeD/W15XdJIAwNDCDBRmmuAURZw5JF+5vV+2q7ydQxKiyFx99dWoq6vD448/jurqaowYMQLLli1DaWkpANcLOKqqqpTjrVYr7r//fhw5cgQpKSk49dRT8cknn+CCCy5I1FMAAASoUCEiIiLqVsYPdCdJOuuBIyIiShZxLW4/duwYPvnkE7z66qs+9y1duhSvv/46CgoKMGPGDMybNw8ZGRl+H8discBisSh/bm5ujts5EyW75g67sibL/7otz6GFXJzub0AQVZIk1CGJtG4rPy1YksS3uD3kThKLw+OcvEXSSRLJkMSo0+Lje34KAEhVDWyKpSHJUQ5JiCI2a9YszJo1y+99S5Ys8fjzAw88gAceeKALzoqIiIio5ykfkAOdRkBNcwcON7SjJDc10adEREQUlbgOSV599VVkZGTg8ssv97j95z//OcrKylBYWIjt27dj7ty5+P777332icsWLFiAxx57LJ6nStRjyKXtKXqtR1+Gu7jdcxBQLw0pbA7f/S7ysCWSJElaiEOSJin1kqUa6CiPYdDCoNPAanf6LW4PO0li9D/QiCRJohS3G8LbWpjvJzHDJAkReeK+LSIiIuq+UgxajOiXha2HGrGhsp5DEiIiSnphd5KEY/Hixfj5z38Ok8nkcfutt96KqVOnYsSIEbjmmmvwn//8B19++SU2b97s93Hmzp2LpqYm5e3QoUPxPG2ipNag9JF4Dh1S/QxJRFFUhiR2p++AwF3cHv63inSTNCQJ0knS1skqLEEQlARJrkeSJNadJPLjRdBJEkaSJJB+Oa4hSXVjB5xOXhwlIiIiIqLubUKZq5dkQyXL24mIKPnFbUiyZs0a7N69G7fcckvQY0877TTo9Xrs3bvX7/1GoxGZmZkeb0TkX4OUJMlO9VxfJa93alcNSVotdlgdrsGA3c/FeXsUSZJQO0nM0vkESnlcflo/DClIR/mAHOU2Y5jJD7O0YizQui1DBEOSDnvshiQFmSZoBMDqcKK21RL8HYioR+I2byIiIkoWSnl7BYckRESU/OI2JHnllVcwduxYjB49OuixO3bsgM1mQ1FRUbxOh6jXkNdt5aR5Jkn8rduSUyQAYO9k3ZZWG0EniZQkaQmWJJEGGKkBStV/c94wfHHvWchKcT+fcJMf8jkESpIYtK7PjTwwCkW71XVsOJ0kgei1GhRmuhJ3h7lyi6jXExkoIyIiom5uXKnrRWz7T5hRxxd6ERFRkgt7SNLa2oqtW7di69atAICKigps3boVVVVVyjHNzc145513/KZI9u/fj8cffxwbN25EZWUlli1bhiuvvBLl5eWYNGlS5M+EiAAADWbXui2fJIl0Mb/d5h5a1LaqhySBi9uj6SQxd5IksdqdSheKvA4sFOF2iMjnELC4XS8NXWwRdJLEYEgCsLydiIiIiIiSR06aAUMK0gEAGyobEnw2RERE0Ql7SLJx40aUl5ejvLwcADBnzhyUl5fj0UcfVY556623IIoirr32Wp/3NxgM+Oqrr3Deeedh6NChuOeeezB9+nR8+eWX0Gpjc7GRqDdTkiSpYSZJ/Kzbckg9Jdo4rdtSr/4KlCTxRxmShJj8CDYkMWjDezxRFNGuFLfH5vuW3EtypIFDEqLeShC4cIuIiIiSx7iB7CUhIqKeIfSrkpIpU6ZADLIH4rbbbsNtt93m976SkhKsWrUq3A9LRCFyF7f77yQxW9RDEncsOtadJEpxeydDErkrRK8VlMFHKIw612Ai1ORHq0XuPQmWJAmtCN7mEJVVZLHoJAGAflKS5AiTJERERERElAQmDMzFG99VcUhCRERJL26dJETU9VotdqzacwIA0FfquJDJ66zU67bqVEkSm58UhUNahaXVhP+tQk5tdNZJIqdawkmRAO7khyXsJIn/gUa4SZJ21TCF67aIKNZYSUJERETJYHyZK0my42hzp2uWiYiIujsOSYh6kPkf7kBVfRv6Zafg4tHFHvf5XbfV2nlxe1RJEmXdli3gMe7S9vAGDeEmP+TESuAkSXjJFLmPRCO4UjCxIK/bOsx1W0S9FpdtERERUTLpl52CftkpcDhFbKlqTPTpEBERRYxDEqIe4qPvj+I/mw5DIwBPXz0GWSmenSRKkkQ1JKkL2kkiJ0kiH5J02Jx+S+EB9+qvcIck4SY/5JVfgYYk4T6eurQ9Vh0C/ZgkISIiIiKiJDN+YA4AYD1XbhERURLjkISoBzjc0IaH398GALjr7JMxQYo9q6X6SZJ4DEn8DAiiSZKoBxLqHhS1tiAJj0DCTX4EK243Sn0oFntoyZRYl7YD7nVbzR12tHQETt8QUc8XpPqNiIiIqNuQV25tqOCQhIiIkheHJERJzu5wYvZbW9HSYUf5gGzcc+5gv8el6F0DAo91W0GK2x1O1xBCE8GQxKDTKMOHlgArt+RzCbfXI9zkhzlYcbt0nlZ7iJ0k0nnHqrQdcA1w5PQPy9uJeinu2yIiIqIkM2Gga0iy5VBDyL9PERERdTcckhAluSXrKrHxYAPSjTr87epy6LT+v6zd67bchXrqThJ/xe3RJEkAIMMk95L4L/GLPEkSXieJnMwIWNwe7pDEFtlwJxiu3CIiIiIiomQyqE86slP16LA5sf1oU6JPh4iIKCIckhAluS93HQMA3DttCAbkpQY8Tlm3ZXNAFEWIouixbssR404SwD38MAcYknRFJ4koijBLyY90o97vMUadtL4rxCFJRxzWbQHu8vYjLG8n6tVE7tsiIiKiJKHRCBhX6kqTbGQvCRERJSkOSYiSmNMpYseRZgDAGSfldXqsfEFfFF3DgDarw2MoYHP4XpSLNkkid4C0dARJkhgiTJLYnUEvJlrsTmXYkxarJInVdZxJF58kyZHGjpg+LhERERERUbxMKJPK2ysaEnwmREREkeGQhCiJHWpoQ4vFDoNOg8EF6Z0em6oaRLRZHahTrdoCALvTd0DgkAYn2gArvIKRhySB121Flsgwat0DH39dKmrqjx1oGOMubg8vSWKKdZJEGZIwSULUG7GShIiIiJLReKmXZOPBejiD/H5GRETUHXFIQpTEtkspkuGFGdAHGWRoNYKSmGiz2lGnKm0HAHsckiRKJ0nAJIlcqB7mui2d+7kGS3/Iq75SDdqABfSRd5LE9ltosTwkaWiL6eMSUXLhpQUiIiJKJiP6ZSFFr0Vjmw37TrQm+nSIiIjCxiEJURKTi/FO7ZcV0vHu8nYH6s3BkyROMTadJIGSJO4BRnjrttRDkmDpD/ljd1YOLydJrA5nSK986ohXcXuOXNzOdVtERERERJQc9FoNygdkAwDWV7CXhIiIkg+HJERJbPsR15BkRHGIQxLpon6b1eFR2g7EJ0kSdN2WNGxIC3NtlVYjKOcUPEkil7YHHpJ4JFNCKINvj3BNWDDF2SYAwLGWDthDOA8i6lkEgQu3iIiIKDmNk1ZubWB5OxERJSEOSYiSlCiK2HHUtW5rRL/MkN5HvqjfpkqSZEorsWx+EhQOKV0SaZIkPdi6rQiTJIC6R8TR6XFmJUkSeKARTjIFcK/bMsU4SZKTagDg6loJVHZPRD2fyH1bRERElGQmyEMSJkmIiCgJcUhClKSqmzpQb7ZCpxEwpCAjpPeRhxHtNjvqWl2dJAWZrvSCv+SCnC7RaSL7VpERbN2WlMhIDbOTBAi9R0RZt9XJIMagDb3jBIjfkESv1Sgr0Zo7bDF9bCIiIiIiongpH5ANrUbA0aYOHGlsT/TpEBERhYVDEqIkJa/aGlyQEfLFenWSRF63VZjlGpI4/CZJouskkVdctQRat2UNPsAIxKhzPZdQO0k6W7clCO5S+1DWbXXYXMfEupMEADJNegBAczuTJES9DZdtERERUbJKM+owoti14YBpEiIiSjYckhAlqe3yqq3i0FZtAe7idvW6rT4ZRgCAzV+SJMpOErks3RxwSBJ5t4dBWbcVrJNEGpKYOh/EKOu7bJ2v7wLiV9wOAJkprvNkkoSIiIiIiJLJeGnl1nr2khARUZLhkIQoSe2QS9v7hVbaDriHJO2qIYmybquzJIk2siFJRtBOErm4PX6dJMq6rU6SJOrHC6e43RTj4nbAnSRpaueQhKi3EsFSEiIiIko+48vYS0JERMmJQxKiJLVNGZKEniRJ0bsGBW1WB+papSGJlCSR+0fUok2SpBtdF/wDd5JIxe1x7CQxh7BuC1Ct77KF3kkSjyRJVoq8botDEqLeRuC+LSIiIkpi40pzAAB7j7eiQXpRHhERUTLgkIQoCR1v7sDxFgsEARheFP66rXar3U+SxHc44JBui7iTREqStPhJkoiiqCQyIkmShF7cHtrHCKeTJJ5Dkkx5SMJ1W0RERERElETy0o0Y1CcNALCBK7eIiCiJcEhClIR2SH0kg/qkIzWMAYM8JKkzW5UL/X3lIUknSRJthC9vTpcSInJiRM3qcCqPH0kniTHMTpK0IGkVdydJKMXt0rotfey/hWZKgyUWtxP1Yty2RURERElqgrxyi0MSIiJKIhySECWh7fKqrTBK2wH3MOJwQzsAV3pCXu/kr7hd7iTRRdhJoqzb6rBDFD2v+sl9JIB7eBMOg7QeK1brttxJkkQXtzNJQkRERESUbBYtWoSysjKYTCaMHTsWa9as6fT4pUuXYvTo0UhNTUVRURFuuukm1NXVddHZxo9c3r6hsiHBZ0JERBQ6DkmIktD2o+GXtgPulVOHG9oAAHlpBuilAYi/4nY5XaLVRPatQl63ZXeKPokPOV1i0Gmg14b/+KEmSUItbjdoQ0+SyCkcFrcTUSwJYCkJERFRMnr77bcxe/ZsPPLII9iyZQsmT56MGTNmoKqqyu/xa9euxQ033ICbb74ZO3bswDvvvIMNGzbglltu6eIzjz15SLL9SBPa/GwUICIi6o44JCFKQtuPuNZthTsk8U6S5KYZoJOGA/6GJI4oi9tT9VqliNi7l0TuI4kkRQKoO0k6T37Iw5igxe36MDpJrK5jWNxORPHAbVtERETJ5amnnsLNN9+MW265BcOHD8fChQtRUlKC559/3u/x3377LQYOHIh77rkHZWVl+OlPf4rbb78dGzdu7OIzj73+OSkoyjLB7hSxtaox0adDREQUEg5JiOKsqd2GtzdUxSwZ0GC24kija8hxSpjrtuSBhJy+yE0zQC8NQOx+hgNKJ0mEQxKNRlDSK3KiQ2aOorQdCCNJIg1n5FRLIOEkSeK7bkvqJPFTdk9ERERERN2L1WrFpk2bMH36dI/bp0+fjnXr1vl9n4kTJ+Lw4cNYtmwZRFHEsWPH8J///AcXXnhhwI9jsVjQ3Nzs8dYdCYKgpEnWs5eEiIiSBIckRHH26rpKPPjuNry6rjImjyeXtg/MS1VWM4XKO7WRl2ZQBiBOEXB6pUkcTtfAINIkCeBOcJi9hiRt0p8jTZIYlSRJ50MNeTgVNEkidZxYgiRJRFFU1m1FUjgfjPx3yiQJUe8jcNsWERFR0qmtrYXD4UBBQYHH7QUFBaipqfH7PhMnTsTSpUtx9dVXw2AwoLCwENnZ2Xj22WcDfpwFCxYgKytLeSspKYnp84il8QNzALC8nYiIkgeHJERxdqLFAgCobuqIyePJfSSnhrlqCwBSvFIbeelGZd0WANicngOCaJMkgDvB4b1uq01etxVkeBGIMtToZEhSb7aioc01bCjNS+308QwhDl1sDlFZQ2bSsbidiGJP5L4tIiKipCN4vdpBFEWf22Q7d+7EPffcg0cffRSbNm3CZ599hoqKCtxxxx0BH3/u3LloampS3g4dOhTT84+l8WWuJMnmg42whbDOmIiIKNEiuzpJRCGTVzO1xOii955jLQCA4YUZYb+vd2ojV1XcDrg7SGROpZMk8nmqnODwvugvd4WkRriyShlqdPJD917pc9U/JwWpQdZ6udd3dd5xIqdIAMBkiP2cmcXtRERERETJIz8/H1qt1ic1cvz4cZ90iWzBggWYNGkSfvOb3wAARo0ahbS0NEyePBl/+MMfUFRU5PM+RqMRRqMx9k8gDob0zUBWih5N7TbsONqMMSXZiT4lIiKiTjFJQhRn7cqQJDYdE7WtVgBAQaYp7Pf17tDISzN4DEBsDs8hiZIk0UaeJMlJlS76t3le9JeTJGnG6NZtWWyBhxp7j7cCAIYUBB8ohZokkT+eRnD3mMSSXNzeYXMGHdgQEREREVFiGQwGjB07FsuXL/e4ffny5Zg4caLf92lra4PG64VoWq3r9yKxB0RKNRoB40pdK7c2cuUWERElAQ5JiOKsQyoCj1WSpK7Vtb4rPz38VxH5S5Ko+0a8y9sdSpIkmiGJAQDQ0Gb1uN2sdJJEFmiTBxShJEkG900P/nghFsG3q0rbA8Xno6EumI/VYI2IkouI5L84QkRE1JvMmTMHL7/8MhYvXoxdu3bh3nvvRVVVlbI+a+7cubjhhhuU42fOnIn33nsPzz//PA4cOID//e9/uOeeezBhwgQUFxcn6mnElLxya30FhyRERNT9cd0WUZzJaYBWS2wueNdJSZK8dEPY7+s9kMhLN0CjEaARXMXtdtW6LVEUY9JJkiUlSRq8kiTtUSZJQhlqyEmSwSEkSeSOk2BJkniWtgOuz3WGUYcWix3N7baIhmFERERERNR1rr76atTV1eHxxx9HdXU1RowYgWXLlqG0tBQAUF1djaqqKuX4G2+8ES0tLXjuuedw3333ITs7G+eccw7+7//+L1FPIebGD3QNSTYebOi0n4WIiKg74JCEKM7kYUAsUgGiKKLOHHmSxPvCfm6a6zF0Wg2sdqfHkERdTxKLJEmjd5LEKicyIi1uD2NIElaSJEgniXTepgi7VEKRmaJ3DUmYJCHqVXjxgIiIKHnNmjULs2bN8nvfkiVLfG67++67cffdd8f5rBJnZL8sGHUa1Jut2H+iFSf3Db9Tk4iIqKtw3RZRnHXYYzckae6wK70huWmRJEm8OkmkNIpeGoKo123Zne7/jiZJkqMkSTyHJG1ScXvkSZLOkx+NbVacaHENlE4OYUhiDLGTRE6SxHtIArC8nai36gGryImIiKiXM+g0SmH7+oqGxJ4MERFREBySEMWZ3EnSarErHR+RkvtIMoy6iC7S67Ua6KUSdr3WtdYJcA9B1MXt6nPVaSL/VpGtdJJ4XvA3W1zDhkg7SYIlSeQUSb/sFKQZg3+MUJIpANCh6iSJl0ypl6SZQxIiIiIiIkpSE6Rekg0sbyciom6OQxKiOJPXMwHR95LUmSPvI5HJF/dz0wzKahe9VIKuTo+oV29FlyTxv26r3SYXt0fXSWINsB5rj1zaXhA8RQKEniSRh15xHZJISZLmDg5JiIiIiIgoOcm9JBySEBFRd8chCVGcqTsuWqK86C0nSfKiKPOWkxtyHwkA6LTyui1VksShTpJEPiTJDlDc7k6SRDZsCJokORZ6HwmgHroEWbcld5LEqbgdADJN0pCknZ0kRL0JG0mIiIioJzmtNAcaATjc0I7qpvZEnw4REVFAYQ9JVq9ejZkzZ6K4uBiCIOCDDz7wuP/GG2+EIAgebz/5yU88jrFYLLj77ruRn5+PtLQ0XHzxxTh8+HBUT4Sou5KTB0D0vSS1rVKSJII+Epk8lFA/hrxOS50eUf+3JpokSZo7SSKqFu27O0kiW7cVbKixTy5tLwitINAodZwEW7fVrqzbit+MOTNFWrfFJAlRr8RKEiIiIuoJ0o06nFqcBQBYX8E0CRERdV9hX+Uzm80YPXo0nnvuuYDHnH/++aiurlbeli1b5nH/7Nmz8f777+Ott97C2rVr0draiosuuggOh/+1OUTJTL6oDkQ/JKmThyRRJElSDO51WzJ3ksQ9IJA7SaJJkQDu4nabQ4RZtXqszRptkqTzoYaybivGSZKu6CTJYnE7ERERERH1AFy5RUREySDsl3DPmDEDM2bM6PQYo9GIwsJCv/c1NTXhlVdewb/+9S9MnToVAPD666+jpKQEX375Jc4777xwT4mo27I5nB4F6FGv2zK71m3lR9FJoiRJ0tVJEt/idrmfJJo+EsA1TDDoNLDanWgwW5EuJUfcQ5LYJ0ma2mw43uL6XIWaJDFo5fVdnQ9rlXVbcS1ul9dtcUhC1JsI3LdFREREPcyEshws/l8FNlQ0JPpUiIiIAorLvpivv/4affv2xZAhQ3Drrbfi+PHjyn2bNm2CzWbD9OnTlduKi4sxYsQIrFu3zu/jWSwWNDc3e7wRJYMOm+cF96iL22OwbitFGkqoH0MublcPdGKVJBEEQUmTNKp6ScyW6Irb3Z0kvkONfSdcKZLiLJMylAn6ePrOO05kcjIorkMSpbidnSREvZF6NSERERFRMhtb6kqS7D7WgsY2a4LPhoiIyL+YD0lmzJiBpUuXYsWKFfjrX/+KDRs24JxzzoHF4npVd01NDQwGA3Jycjzer6CgADU1NX4fc8GCBcjKylLeSkpKYn3aRHHR7jUkifaid20MituLs0wAgNK8NOU2ed2WzekeEMidJNEmSQAgJ9U1kGlQ/VAsJ0ki7SQxdpIk2SOVtp8cYooEcCdJgq/bct2fEtfidqmThEkSIiIiIiJKYn0yjDgp3/W758ZKpkmIiKh7ivmQ5Oqrr8aFF16IESNGYObMmfj000+xZ88efPLJJ52+nyiKEALsmZg7dy6ampqUt0OHDsX6tIniwmLzvOAe/botuZMk8iTJg+cPwz9uGIcZI9wr8bRycbvDT5JEG/23iWwpSSIPSURRVIrbI02SdLZua680JBkSYh8JABj14Ra3d0WShEMSot6E67aIiIioJ1J6SQ6yl4SIiLqnuKzbUisqKkJpaSn27t0LACgsLITVakVDg+crCI4fP46CggK/j2E0GpGZmenxRpQMvNdtRV/cLneSRJ4kyUkzYNopBR7DD73Gt7hdHpjEMkkir9uy2J2QN3vFo7h973GptL0g9CGJu5Ok+xS3N7dz3RZRb8RlW0RERNSTjC+ThiQVHJIQEVH3FPchSV1dHQ4dOoSioiIAwNixY6HX67F8+XLlmOrqamzfvh0TJ06M9+kQdSnvdVvRJEnsDicapCFDNJ0k/sjrtuyqThKnGJtOEgDI9lq3ZVZ1s0Rb3G53ih5dKoA7SXJy39DXbcmdJNZQi9vjuW4rxV3czm4CIiIiIiJKZhOkJMm2I00+LyQkIiLqDsK+Otna2op9+/Ypf66oqMDWrVuRm5uL3NxczJ8/H1dccQWKiopQWVmJhx9+GPn5+bjssssAAFlZWbj55ptx3333IS8vD7m5ubj//vsxcuRITJ06NXbPjKgb6PBZtxV5MqBeGjBoBPfQIVbk4nZ73DpJPIvb5T4Sk14T8ePLnSSAa+WW3BHS3GFDTXMHgPgkSZTidl38ZsxyJ4nV4YTF7oxrSTwRdR8CuG+LiIiIep6S3BQUZBpxrNmCLVWNOGNQXqJPiYiIyEPYV/k2btyI8vJylJeXAwDmzJmD8vJyPProo9Bqtdi2bRsuueQSDBkyBL/85S8xZMgQfPPNN8jIcL+i++mnn8all16Kq666CpMmTUJqaio++ugjaLW8EEg9SyzXbdW2uIYkuWmGmAwu1OTHs3l0kriGBbFIkngXt8tDkkhTJIA7SQJ49pLIKZLCTBMyTfqQH09JkjicnaY3lE6SOCZJ0gw6yJ92lrcThWbRokUoKyuDyWTC2LFjsWbNmpDe73//+x90Oh3GjBkT3xMMBwNkRERE1IMIgoBxci9JJVduERFR9xP2FcopU6Z0egHx888/D/oYJpMJzz77LJ599tlwPzxRUonluq06s6uPJC8t8j6SQHR+ittj2UniLm53PX9zlKXtgGt4oxEApwhY7A4Aro+xL4I+EgAwSkNaUXSlaPRa/8+7KzpJNBoBGSY9mtptaO6woW+mKW4fi6gnePvttzF79mwsWrQIkyZNwosvvogZM2Zg586dGDBgQMD3a2pqwg033IBzzz0Xx44d68IzJiIiIupdJgzMxSc/VHNIQkRE3VLcO0mIerNYJknqWl0pjLz02K7aAqAMBByqdVtyz4c8QImGu7hdSpJYXJ+XtCiSJIIgKGkS9YqsPVKSZHAYfSSAZzKls5VbXTEkAdzl7U0sbycK6qmnnsLNN9+MW265BcOHD8fChQtRUlKC559/vtP3u/3223HdddfhjDPO6KIz7ZzAbVtERETUQ42XkiSbDzbA7uh8xTEREVFX45CEKI4sUidJrlS0HtW6rVYpSZIehySJ1MehXrcV006SNDlJIq/bkpIkxugGDf56RPYel4YkYSZJAq3v8qZ0ksRx3RYAZKa4Bkhct0XUOavVik2bNmH69Oket0+fPh3r1q0L+H7//Oc/sX//fsybNy/epxg2kfu2iIh6hQ6bAyt3H2eRNfUKQwszkGHSwWx1YFd1S6JPh4iIyAOHJERxJF9Q75vhGmxEt25LSpKkxT5JIveO2P0lSQKsnQqHXDTfaPYsbo9m3RYAGKU0h3qosV8ekvQNb0ii1QjK58G1vsu/dqvrY8U7SSL3qTRH8W+GqDeora2Fw+FAQUGBx+0FBQWoqanx+z579+7FQw89hKVLl0KnCy3RZrFY0Nzc7PFGREQUjYff34ab/rkBv/nPD4k+FaK402oEjCvNAQCs58otIiLqZjgkIYoj+VVhfaQhSavF3mmnT2fqpCRJfhzWben8FLfHNEkiDUlaLHbYHE5VJ0nk67YAd5LEKsW1HU4RNc0dAICS3NSwH88opUk6S5LIf6emrhqSMElCFBLBa1eVKIo+twGAw+HAddddh8ceewxDhgwJ+fEXLFiArKws5a2kpCTqcyYiot7tvc1HAAAffX80wWdC1DXGl0nl7RUckhARUffCIQlRHHVI67b6SCuynCJgtkYWp3d3ksRv3ZacHnH9t+vctTFYkp+Vold27Te22dBulTtJok2SSOu2pMHF8ZYOOJwidBoB+RF8nvx1nKjVm63KgCfDFN2AJxhl3VYUK9qIeoP8/HxotVqf1Mjx48d90iUA0NLSgo0bN+Kuu+6CTqeDTqfD448/ju+//x46nQ4rVqzw+3Hmzp2LpqYm5e3QoUMxfy6sJCEiIqKebILUS7Khsj7iFw8SERHFA4ckRHEkr9vKTjUoaY1gK7c2HazH/e98j8MNbR6318Zx3ZZc3K4u0ItlkkSrEZRkRGObFWapuD0lxkmSo42uFElBpimi8zbqfNd3qX2yrRqiCIzolxnRECYccnE7kyREnTMYDBg7diyWL1/ucfvy5csxceJEn+MzMzOxbds2bN26VXm74447MHToUGzduhWnn366349jNBqRmZnp8RYvvGZAREREPdHI/lkw6DSoM1txoNac6NMhIiJSxPel0ES9nHs1kwYZJh0a2mxo6bCjKMv/8V/tOoZZSzfDYnciJ1WPRy48RbmvLo7F7fJAweaRJIldJwkA5KTq0dRuQ0ObTSlujz5J4np/i5TYqW5qBwAUZ5siejx3ksR/2ueDLa6VCJeO6RfR44dDHio1cUhCFNScOXNw/fXXY9y4cTjjjDPw0ksvoaqqCnfccQcAVwrkyJEjeO2116DRaDBixAiP9+/bty9MJpPP7UREREQUO0adFmP6Z2N9ZT02VNRjUJ/weiSJiIjihUMSojiSL7an6LXIMOmlIYn/i94fbDmC+975XhlObD/iWQosr9uKRyeJ3s+6LbtDTpLEJnCWnWoA6trQ0OZeWZVqjO5bkNErSVItJUmKslIierzO1m1V1bVh08EGaARg5ujiiB4/HJkpLG4nCtXVV1+Nuro6PP7446iursaIESOwbNkylJaWAgCqq6tRVVWV4LMMQQzWGxIRERF1Z+PLcrC+sh7rK+txzYQBiT4dIiIiAFy3RRRXcveGSa9VOiz8dUy8uq4Ss9/eCodTxOlSmd32o03KntY2q11Z3RWXThKluN09HFCSJDFYtwW4kiSAa91WW6w7SaRh1FEpSVIUYZKks+L2D7a6UiSTTs5HQWZkjx8OpZOknZ0kRKGYNWsWKisrYbFYsGnTJpx55pnKfUuWLMHXX38d8H3nz5+PrVu3xv8kQ8R1W0RERNRTjZd6STZWNiT4TIiIiNw4JCGKI7m4XV63BQCtXkOSj384inkf7gAA3DhxIF67eQIMWg1aOuw4VO+66C+nSIw6TdSDBX/k4nY5PQLEtpMEAHJSXQmYhjYb2qROktQon4vSSWL3TJIUxzhJIopil67aAtzrtpgkISIiIiKinmJsaQ40AlBV34ZjzR2JPh0iIiIAHJIQxVWHXZ0kcV30bvEakqzYdRwAcM34EsybeQqMOi2GFmYAcKVJAKBW6iPJTzdCiMM6FjktYneqkyROj/uila0MSVTrtqIsbncnSTw7SYqyYpsk2XakCQdqzTDpNThvRGGkpxsWFrcT9T5ctkVEREQ9XYZJj+FFmQCA9RX1CT4bIiIiFw5JiOLIY92W1L/h3UlSI7165icn5SkDkBH9XD80bj/iGpLISZK8OPSRAO5y9vgmSaR1W2abe92WMbZJkqNNUpIkO9IkiVQE7zUkeV9KkUw7pRDpUfaohEruJGFxO1Hvw21bRERE1JPJK7c2VHJIQkRE3QOHJERx1GGX1225O0m8kyQ10oV9dc/FqcVZAIDtR13l7XVmd5IkHvRSObtdVdwe606S7DR3kkQekqREmSRRr8ey2p1K4iaWSRK7w4mPvj8KALisPP6F7TL3ui270k1DRERERESU7OQhCZMkRETUXXBIQhRHFqlsPcVj3ZY7GSCKopIkUV/YH9nPNSTZccRV3l4rJ0nS4psk8VfcrtXE5tuEu7jdhjZp3VbUxe2q5Mex5g6IomvQkRvh58k9dHEot63dV4vaVity0wyYPLhPVOcbDrm43eEUlaESEfVscdimSERERNTtjC/LAQDsPtbC5DwREXULHJIQxVG7TV63pfGbJGnusCsXwAtVQ5KhhRnQagTUma2oae5QrduKT5JE6STxs24rVkmSHHUniVLcHpskidXuxNFGdx9JpL0t/pIk/93qSpFcNKoIem3XfctM0Wuhl4ZX6vL2jZX12CF11RBRz8T0GBEREfVkfTNMGJiXClEENh9sSPTpEBERcUhCFE8dNt/i9mbVkOSYlCLJTtXDpHenKkx6LQb3TQcAbD/SrFq3Fa8kSeB1W1ptrIrbXc+/oc2GdjlJEmUniVGV/KhukhM5kfWReD6ea0jicIpYvvMYAOCSMf2iOdWwCYLgXrnV7vp8HW5owzUvfYtrX/rWI+1CRERERESUTJSVW+wlISKiboBDEqI46rD56yRxpwLkC/uFmb4dGiOklVvbjzTFv7hdTpI4VV0ccUqSNLZZ0SavIYty3ZZHkqRJSpJkR9ZHAvgWwVfVt6HVYodRp8GYkuyozjUS3uXty3ceg90pornDjm2HmSYhIiIiIqLkNL5MKm9nLwkREXUDHJIQxVGwdVvH5CGJn6LxEcWZAIAdR5uUQvK8tDgVt8tJEoc6SeIaFGhjPCSxO0XIm2TSoly3pe4kqW50fS6Lo0mS6OXHc/297a5pBuBef9bVMqV/M83SkOTLXceU+/iKK6KeR/4uw2VbRERE1NNNkJIkPxxuUjYwEBERJQqHJERx4nSKSiJBvW6r1eIekrhXRHWWJGl2F7fHKUkiDwDUxe2xTpKkGLTKOivlNn3skiTVcUiS7KpuAQAMK8yI5jQjJidJmjtsaGq34bsD7sHIer7iioiIiIiIklRpXiry042wOpz4/lBjok+HiIh6OQ5JiOLEoir/TtFrlVSAet1WTbPrwn6Bn3Vbw4syIQhATXOHkiTJj1Nxu1wQ7lB3kkipEk0MExRymgQAUg3aqB9b3UlyNBZJEnnoIg2LfpSSJMMKM6M5zYgpQ5J2G77efRx2p4h0o+vf0abKBo+/LyIiIiIiomQhCAImlOUAADYwJU9ERAnGIQlRnLSrIsMmvRbpqnVborRvqqaTJEmaUYeT8tM8blMPGWJJp3F9K7CpLrrHOkkCuMvbAdeQJFoxT5LIQxebPCRJcJJELm7vsOMLqUD+5z8ZgDSDFi0WuzLEIaKeQRC6fq0fERERUaK4y9sbEnwmRETU23FIQhQn8l5VvVaAViMo67bsTlEpdJfXbflLkgDASGnlFgBkpeiVi/ixppOSJHbVui05paDVxO5jeiZJousjAdzJj6Z2GxraXAmdohgkSSwOJ8wWOw7WtQFwdZIkQmaK63NU22rBqt0nAADnn1qIsQNZckjUk4kMiREREVEvIA9JNh9kSp6IiBKLQxKiOOlQSttdiYk0gxZyKENeuXWsWU6S+L+wP0I1JIlXHwngTpKoi9vjkSTJSYttkkQeasjDjDSDe61ZJAxyEbzNid3HXCmSvhlG5MVpzVkwcpLky53H0Gqxo0+GEaP7Z2PCQDmWzldcERERERFRchpelIkMow6tFjt2VTMlT0REicMhCVGctHsNSQRBUPokmjvs6LA5lPRDYYAkyanF7iFJflr8LtQrSRKnOkni+m9tTNdteXaSREtO1tSZXcX2RdkpUa2rUXeS/CiXthclpo8EcHeSHJUSR1OH94VGIyivuPquol5Z3UZEyY/LtoiIiKg30WoEnFbKXhIiIko8DkmI4kReqWXSu7/M5JVbLR02JUWSotcqa5W8nVLsvkAfzySJXhmSxDlJouokSTPGYt2W56DFX7dLONydJA6l72N4glZtAa4Va2rTTikAAIwuyYZBq0FtqwWVUoqGiHoSDj+JiIiod5hQJq0S5pCEiIgSiEMSojixSEmSFL37Qn6Gqrxd7iMpzDIFTD9kpehRmpcKoOvXbbk7SWI5JIlPkkRWHEUfifrxPJMkiRuSqFeHpei1mDgoH4ArnTS6xJUyYi8JEREREUVi9Z4TOPPJlfj2QF2iT4V6sXFSkmR9RQNT8kRElDAckhDFife6LcDdMdFqsStJkkCrtmQjpJVb+XHsxZAHITZVcXs8kiTqdVtpMSxulxVlR5ckkR+vw+bELilJMqww8eu2AODMIfke/5bklVvr+Yoroh4jim2BREREYbth8XpU1bfhmpe+TfSpUC/GlDwREXUHHJIQxYmybkvnL0li80iSdOaOswbh4tHFuOK0/nE6U0CvdX0rcKjWbTmkVIlWG7tvE+p1WyndOElyqL4NLR126DQCBvVJj+oxoyEP1QBg2imFHveNZyydqMfiiyiJiIiotzDptRjVnyl5IiJKLA5JiOKkQ06SGPyv26oJcUgysn8Wnrm2HCW5qXE6U3dxuzpJ4hDjnCSJRydJ1EkS1+O1WuwAgJP7pvsMYrpSfroBWo0ArUbAOcP6etw3tjQHggAcrGtTUklERERERETJhi8AIyKiROOQhChOlHVbqovs6dKQpFk9JAmybqsr6OVOEme8O0ncyYh4dJIURZkk8V7fNSyBpe2Aa6j0t2vG4MVfjEVummcnTaZJj1OKXKvA1vMVV0RERERElKQmDOSQhIiIEotDEqI46fDTSZIhrU9q6bChujm0JElX0EpJEnVxezw6SWJd3O491CiOUSeJbFhR4vpIZBeNKsbUUwr83jeev0wQ9SgCXN9vuW2LiKjnsasS20Tk6TQpJV9Z14bjLUzJExFR1+OQhChOLHbXL0Ipev/rto51qySJNCRxqtZtSf8dyyRJZopeKSZOjUFxuzpJkpWij/oxvZMpiU6SBDNBiqUzSUJERETUfVXVteHUeZ/jj5/sTPSpEHVLWSl6DCt0vUBtQ0VDgs+GiIh6Iw5JiOKk3SonSdxfZnKSpLHNprxCpqgbJEl0Ujm7UwScUoJETpXoNLH7NqHVCMhKcX0O0owxWLelKpWPxefRe0gyvBskSTpz2oAcAMCeYy2w2vnqRCIiIqLu6JkVe2GxO/GPNRWJPhWibmv8QNfvNkzJExFRInBIQhQn/tZtZUpJkgO1rXCKrlVWeenGhJyfmlzcDgA2KUESj04SwL1yKxZJEvV6rOLs6PpIXI/n/rvKSdWjb0bi/246U5BpRIpeC6cIHGlsT/TpEFG0pG+3IvdtERERUS8jrxJmSp6IiBKBQxKiCISyU7jD7q+TxDUYOFjXBgDom2GM+RAiEureETlBYo/TkOS0ATkwaDUxWWUlCIKSJolFt4s6STKsMBOCkPi/m84IgoABuakAgIN15gSfDRERERERUWTkVcK7aprR3GFL8NkQEVFvE/aQZPXq1Zg5cyaKi4shCAI++OAD5T6bzYYHH3wQI0eORFpaGoqLi3HDDTfg6NGjHo8xZcoUCILg8XbNNddE/WSIusLK3ccxYv7neH/L4U6Pa7e6Bin+itvllEZ3KG0HPFdqycMRRxyK2wHgzz8bhU2/m4rSvLSYPJ6cJimOwedSnUwZVtS9+0hkJdKQ5FB9W4LPhIiIiIiIKDIFmSYMyE2FKAKbD7KXhIiIulbYQxKz2YzRo0fjueee87mvra0Nmzdvxu9+9zts3rwZ7733Hvbs2YOLL77Y59hbb70V1dXVytuLL74Y2TMg6mKbDzagw+bE+iCFcnKSJMWjk8RzxVR3GZLoteokiWu4E68kiUYjKMOiWJDTH0VZ0a/b0mkEpVh+eGH37iORlebJSRIOSYiSXffOrhERERHFl7xyi70kRETU1cIuBZgxYwZmzJjh976srCwsX77c47Znn30WEyZMQFVVFQYMGKDcnpqaisLCwnA/PFHC2aR1VLYgK7csfjpJvIcDhZnRX9iPBUEQoNUIcDhFVZLE9fxinSSJNfnzW5Qd/cBJEASYdFq02xwYGoN1YF1BXrdVxSQJUY8hgqUkRERE1PtMKMvBu5sPY0OQFyQSERHFWtw7SZqamiAIArKzsz1uX7p0KfLz83Hqqafi/vvvR0tLS7xPhSgm5KRFsCFJu58hSbrRO0nSfYrB5cSILc5Jklj75cRSnDOsL8aW5sTk8X7104G4cFQRRvTLisnjxduAPA5JiIiIiIgo+Y2TkiRbDzfCIm1mICIi6gphJ0nC0dHRgYceegjXXXcdMjPdq2t+/vOfo6ysDIWFhdi+fTvmzp2L77//3ieFIrNYLLBYLMqfm5ub43naRJ2ShwfBhiQdNt9OEt8hSfdIkgCAXiPACncXidJJou3eQ5LbzhyE284cFLPH+815w2L2WF1BnSQRRbHbl80TUWD88iUiIqLe7KT8NOSnG1DbasUPh5uU9VtERETxFrchic1mwzXXXAOn04lFixZ53Hfrrbcq/z1ixAgMHjwY48aNw+bNm3Haaaf5PNaCBQvw2GOPxetUicIiD0es9s7XoXQoSRJ3YEurEZBu1KHVYgcAFGZ2j04SANBpNQAcyjoxu0NOksQ9cEZR6J+TAkEA2qwO1JmtyE/vPukkIoqMyG1bRERE1AsJgoBxpbn4bEcN1lfUc0hCRERdJi5XP202G6666ipUVFRg+fLlHikSf0477TTo9Xrs3bvX7/1z585FU1OT8nbo0KF4nDZRSOThgTWCdVuAZ3l7UTcpbgfc5e12qYtESZJ083VbvZ1Rp0WRNGxjeTsRERERESWz8WWuwchGlrcTEVEXivmQRB6Q7N27F19++SXy8vKCvs+OHTtgs9lQVFTk936j0YjMzEyPN6JEsUlDBJs9WHG76/6UToYkfTO7z6v+dVJiRB4CJUsnCQEl0sqtQ+wlIUpqAvj9loiIiHq3CVJ6ZOPBBuWFe0RERPEW9rqt1tZW7Nu3T/lzRUUFtm7ditzcXBQXF+NnP/sZNm/ejI8//hgOhwM1NTUAgNzcXBgMBuzfvx9Lly7FBRdcgPz8fOzcuRP33XcfysvLMWnSpNg9M6I4kYcIwTtJAiVJ9ACAvDQDjDqtz/slijwMsSudJK7nxyRJ91eal4rvKuqZJCHqIXg5gIiIiHqr4UUZSDNo0dJhx+6aFpxSzBfJEhFR/IWdJNm4cSPKy8tRXl4OAJgzZw7Ky8vx6KOP4vDhw/jwww9x+PBhjBkzBkVFRcrbunXrAAAGgwFfffUVzjvvPAwdOhT33HMPpk+fji+//BJabfe5YEwUiCPE4vZ2P50kgDtJUtCN+kgA1both+e6LSZJuj91eTsREREREVGy0mk1OK00BwCwgSu3iIioi4SdJJkyZQrEThpFO7sPAEpKSrBq1apwPyxRt6EUtzs6/zqQkyS+67ZcSZLu1EcCyMXtUIrb3Z0kLG7v7gbkpQHgui0iIiIiIkp+4wfmYs3eWqyvrMcvJw5M9OkQEVEvwKufRGGyh5AksTlEyOtTjQE6SQq625BE41ncrnSSaJkk6e7kJMnBenOCz4SIoiFI326DveCEiIiSC7+tE4VnvNRLsqGinj8XERFRl+CQhChM8nCksyGJvGoL8F23Na40BxoBmDgoLz4nGCGd1ruTRE6ScEjS3ZVKQ5JjzRYlwURERERERJSMygdkQ68VcLzFwpXCRETUJTgkIQqTUtxuDzwksUgXqjUCYNB6fpldflp/7HjsfFw0qjh+JxkBea2W3SFCFEV3koRDkm4vO1WPDKMrocSVW0RERERElMxMei1G9ssCAGyobEjw2RARUW/AIQlRmOR1VNZOkiQdNtd9Jr0WguA7ZEgxaH1uSzR1cbtTlWjW+jl/6l4EQUAJy9uJkh6/3RIRERG5jC9zr9wiIiKKNw5JiMIkF5tbO0mSyOu2TPruNwwJRE6S2JyiMggC2EmSLErzpF6SOg5JiIiIiMiTwynij5/sxLUvfQt7Jy/2IuouJsi9JJUckhARUfzpEn0CRMlGHiDIwxJ/5F6IlGQakkjDEIfTqfSRAOwkSRYDmCQhIiIi6pZinRQURRE7jjajNC8VGSZ90ONX/ngct/9rk5KEX7XnBM4dXhDbkyKKsbGlOQCAA7VmnGixoE+GMcFnREREPRmTJERhUjpJOl235RqSGPXJ8yUmD0NsDncfCcBOkmQxQEqSsJOEKHkJ4PdbIiIKbuXu47jo2bU4f+GakI6/ackGj1XBnb3YiyK3aNEilJWVwWQyYezYsVizpvO/H4vFgkceeQSlpaUwGo0YNGgQFi9e3EVn2/1lpxowtCADALCRaRIiIoqz5LmCS9RNyMMRu1OE0+n/Fwxl3ZYumZIk7uJ2h0OdJOG3iWQgJ0kOckhClPREXrsiIqJOfPxDNQDgSGO7z32VtWZMfnIFXv/2YFefVq/29ttvY/bs2XjkkUewZcsWTJ48GTNmzEBVVVXA97nqqqvw1Vdf4ZVXXsHu3bvx5ptvYtiwYV141t3f+DJXmmQ9hyRERBRnvPpJFCZ1ysLm9J8mkYvbu2NBeyBKcbvT6fEcGSRJDqW5aQBcSZJAwzsiIiIiSh52hxPVTb6DkM7M+3AHDtW347cfbI/TWZE/Tz31FG6++WbccsstGD58OBYuXIiSkhI8//zzfo//7LPPsGrVKixbtgxTp07FwIEDMWHCBEycOLGLz7x7G89eEiIi6iIckhCFya5KWQSKqlvscnF78nyJaTWqJIl0kV2nESDEeokyxUVRtglajQCL3YnjLZaQ3kcUXQWe7246HOezI3/e33IY17/yHd5aH/gVhtS78NstERGp/eKV73DGghX4Zn9dyO+jXgkc7oCFImO1WrFp0yZMnz7d4/bp06dj3bp1ft/nww8/xLhx4/Dkk0+iX79+GDJkCO6//360twf+O7NYLGhubvZ46+kmlLmGJDuPNqPVYk/w2RARUU+WPFdwiboJ9S8eNrv/JEm7NfnWbek16iSJ63mxjyR56LUa9MtOARB6efuu6hb8Y00FHvlgG6wB/i1T/Hx/qAlr9taios6c6FOhbkYE02BERAR8e8D16vk3InxBxeT/W+n3dg7lY6u2thYOhwMFBQUetxcUFKCmpsbv+xw4cABr167F9u3b8f7772PhwoX4z3/+gzvvvDPgx1mwYAGysrKUt5KSkpg+j+6oKCsF/XNS4BSBzQcbEn06RETUg3FIQhQmj3VbAcrb5eJ2UxKt29Jp3cXt6iQJJQ+llyTEi+4nWl2Jkw6bE9uPNsXtvMi/ilrX39PAvLQEnwkRERH1RHauYO1S3gl8URQDpvKdTicEQcDSpUsxYcIEXHDBBXjqqaewZMmSgGmSuXPnoqmpSXk7dOhQzJ9DdzSBK7eIiKgLcEhCFCb1YMQSKEkidZIkU5JEXdwu/0LFJElyKZGGJIdCTJLUtbrXcm2o4C8dXa2yjkMSIiIiomSXn58PrVbrkxo5fvy4T7pEVlRUhH79+iErK0u5bfjw4RBFEYcP+1+FazQakZmZ6fHWG4yThiTr+fsKERHFEYckRGHy7CQJkiRJok4SOTXicDrdSRJt8pw/AaV5UpIkxCFJvdmq/Dd/6ehaNocThxtcrxIsy+eQhDyJfOEvEVGPtWxbtdJfSD2DwWDA2LFjsXz5co/bly9fHrCIfdKkSTh69ChaW1uV2/bs2QONRoP+/fvH9XyTzYSyHADA1kON/NohIqK44RVQojDJfR1A4OL2DumHtxR9EiVJpOJ2m9O9botJkuQir9sKtZOkTjUk2XiwAU6uZOgyhxva4XCKMOk1KMg0Jvp0eoRFixahrKwMJpMJY8eOxZo1awIeu3btWkyaNAl5eXlISUnBsGHD8PTTT3fh2RIRUbJo7rDh9n9txLJt1TF5vFlLN2PBsh9j8ljUfcyZMwcvv/wyFi9ejF27duHee+9FVVUV7rjjDgCuVVk33HCDcvx1112HvLw83HTTTdi5cydWr16N3/zmN/jVr36FlJSURD2NbmlQn3TkphlgsTux/QhXBBMRUXxwSEIUBlEUPQYjAZMkcnF7Eg1J9FInid3hZCdJklKGJHUhJkla3UOSpnYb9hxvict5ka9KVR9JoF3VFLq3334bs2fPxiOPPIItW7Zg8uTJmDFjBqqq/BfdpqWl4a677sLq1auxa9cu/Pa3v8Vvf/tbvPTSS1185kRE1N09+9VefL7jGGYt3Yw7l26G6BX3+/5QI+a+94PHGlNv3gnBdzYmtkuCP3nE3tVXX42FCxfi8ccfx5gxY7B69WosW7YMpaWlAIDq6mqPn0vS09OxfPlyNDY2Yty4cfj5z3+OmTNn4plnnknUU+i2BEHAuFJXmmR9BcvbiYgoPnSJPgGiZOLweqW9NeC6LamTJJnWbclDEic7SZLVQGltU53ZiqZ2G7JS9J0er06SAK5ekmGFvWO3caKxtD22nnrqKdx888245ZZbAAALFy7E559/jueffx4LFizwOb68vBzl5eXKnwcOHIj33nsPa9aswW233dZl5+1NHphx3RYRUfdRq3pRySfbqvHb5uEoynK/0v+Sv/8PANDYZsPzvxiLH2uasbGyAddNGABNAn6W5msvEmfWrFmYNWuW3/uWLFnic9uwYcN8VnSRfxPKcvHFzmPYWFkPYFCiT4eIiHqg5LmCS9QN2L2GJLYAxe3yuq1kSpJoNe7idoe0UoxJkuSSbtQpq5sOnGgNcjRQb3a94nF4kWswsr6Sr8zqKgfl0nb2kUTNarVi06ZNmD59usft06dPx7p160J6jC1btmDdunU466yz4nGKRETUgwQaZO877vrZ6/yFa/DbD7bjvS1HYvYxfX4i5zCdepnxUnk7VwQTEVG8cEhCFAbv9VqBOknak3HdlkZOkjiVcnomSZLPSfnpAIADJ8xBj5WTJDNGFAIA1lfU+ayQoPiokFaileWnJvhMkl9tbS0cDgcKCgo8bi8oKEBNTU2n79u/f38YjUaMGzcOd955p5JE8cdisaC5udnjjYiIKJDOuhO4apMoPKcWZyLVoOWKYCIiihsOSYjCYPcaigTsJLHL67aSZ0ii00rF7Q4Wtyezk/q4kgn7Q0mSSOsjzh3eF3qtgGPNFhyqb4/r+ZGL3ElSynVbMeN9wUkUxaAXodasWYONGzfihRdewMKFC/Hmm28GPHbBggXIyspS3kpKSmJy3mry2XJUSUSUnOq9VpnGis//L/BHdOpldFoNygdkA3CtCCYiIoo1DkmIwmBzeg5FAneSuJIkKUk0JJGL2x0enST8FpFsBvUJLUlisTvQYrEDAPplp2BEvywAwPpK/tIRb1a7E4cb5CQJhyTRys/Ph1ar9UmNHD9+3Cdd4q2srAwjR47ErbfeinvvvRfz588PeOzcuXPR1NSkvB06lNjSXSIi6hrvh7E267kV++J4JkS9m7xyiyuCiYgoHngFlCgM3kkSa6BOEpu8bit5vsTk1IjN4VSSJOwkST5ykuRAbedJkgazDYDr7z3TpMcE6ZcOvjIr/g43tMEpuoaofTOMiT6dpGcwGDB27Fif4tPly5dj4sSJIT+OKIqwWCwB7zcajcjMzPR4IyKi3idQ2k8QgHbpdwAiij317ytcEUxERLGmS/QJECWTkNdt2ZKvk0Ret2V3qJMkHJIkGzlJUlnbBodTDPh3WCeVtuekGqDRCJhQlosXVx/ABiZJ4q6yTl61lcqd5DEyZ84cXH/99Rg3bhzOOOMMvPTSS6iqqsIdd9wBwJUCOXLkCF577TUAwN///ncMGDAAw4YNAwCsXbsWf/nLX3D33Xcn7DkArgtsRESUnLr0mm0MPlZjW3xWgxHFS/mAHOg0AmqaO3C4oR0luez2IyKi2OGQhCgM3uu2Ag9Jkq+TRF3c7pCeJ5Mkyac4OwVGnQYWaaVToM6LOqmPJD/dAAAYV5oLQQAO1JpxosWCPkw4xE1FLVdtxdrVV1+Nuro6PP7446iursaIESOwbNkylJaWAgCqq6tRVVWlHO90OjF37lxUVFRAp9Nh0KBB+NOf/oTbb789UU/BA18dSUTUM2w/0oQXVu3H8WbPpGK4P2ELAPYca8GPNS2YOaoo6vO679/fK2tXiZJFikGLEf2ysPVQIzZU1nNIQkREMcUhCVEYfNZtOfxfyGpPwnVbSpLEySRJMtNqBJTlp+HHmhYcOGEOOCSRi0Vz01xDkqxUPYYWZODHmhZsqKzHBSOj/wWc/DsoJUkGckgSU7NmzcKsWbP83rdkyRKPP999990JT40QEVHPd9Gza2P2WNOfXg0AyDRF/ys8BySUrCaU5SpDkstP65/o0yEioh4kea7gEnUD3skRW9BOkuRJksipEbtDdHeSaDkkSUZyL8n+E4F7Seq8hiSAqgyRvSRxVVHrGpKUBRhgERERUfLpqpWJO442hx9FIeohxpXmAODvK0REFHsckhCFQU5YyAKt27JI67ZSkmlIonUXt8uJGa2G3yKSkdxLsv+EOeAx9VInSZ5qSDKhzDUk+fiHo3h7QxUsdpaPxoO6k4RITb7mxWVbRETdF1ciEiWO/KKu/SfMqGu1BDmaiIgodLwCShQGRwidJA6nCKsj+TpJdBr3ui0lScJ1W0lJTpIc6CRJ4l635e4eOXNIH/TPSUFtqxUPvrsNZz65Ei+u2o9WrmSIGavdiSMN7QDYSUJEREREFI6cNAMG93W9IGxDZUOCz4aIiHoSDkmIwmALoZNEXrUFJFcniV4rF7ezkyTZnZQfPEkiF7fnpruTJFkpenw2+0w8csFwFGaacKzZggWf/ohbX90Y3xPuRQ41tMEpAmkGLfpkGIO/AxEREfU80f6IrfoVpKnNho++P+rxOwhRTzZeSr9vqOTKLSIiip3kuYJL1A34FLf76STxGJLokidJolU6SZxKYoZJkuQkJ0lqWy1oarf5PUbuJMlXrdsCgHSjDreeeRJWP3A25s4YBgA4UBs4kULhqayVV22lQeiq5eWUNJR/E9zkQkTUbXX+/99d/w38l/9cj7vf3II/fLKzyz82USJMkFZubeSQhIiIYohDEqIw2EJYt9UuDUkMOg00STRk0GuldVuq4nYmSZJThkmPvlJKIdDKrXo/xe1qBp0GZw/rC8A3QUWRk0vbB+azj4SIiIjCJwjwSKJsPdQIAPjvlqMJOR+iriYnSbYfbYaZa4GJiChGOCQhCoN3ksTfkKRDKm036ZLry0tOjdicTmXdFpMkycvdS+J/5ZZcdJiX7n9IAgAGaXBm85OYCoUoivjv1iPYd7wlpOOdThHvbT6Mfcd7bnLlYF0bAGBgHvtIiIiIerO739wS0fuxN556u37ZKeiXnQKHU8SWqsZEnw4REfUQyXUVlyjB7I7gSRJ53VaKIXlWbQGATrog7nCqkyT8FpGsBvVx9ZL4W5VlczjR3OF61ZW6uN2bXhr0Wf38Ow/FD4eb8P/e2oq5720L6fhvK+ow59/f45Ln1mLd/tqIPmZ3V1knJ0k4JCFf8lha5L4tIqJuS4zRlOKj7+OT/BCiLjwh6v7GDcwBAKznyi0iIooRXgElCoPN6d1JEri43aRPsiGJ0kkiMknSA5wkDUn2H/dNkjRIq7Y0ApCdog/4GHqt6+/f6nD6vSDgdIp45qu9WLvX/0CjzmyR/tca0jnLK8DMVgdu/OcGfLGjJqT3SybKui0mSYiIiHqtaH/CPtzQHvC+tft65gtNiNTGS70kGyo4JCEiotjgkIQoDKElSVy3pSTbkES6IG5zOJUkSTJ1qpAnZd2WnyRJnaqPpLO/Y3ndlihC+Teh9sORJjy1fA9+/7H/olCrtKbLGuK6LvXXk9XuxK+XbsZ/Nh0O6X2TgcXuwNFG10UNdpIQERFRpNb7uTAsgkXW1HtMkHpJthxqCPl3DSIios5wSEIUhtA6SVxJEmOSDUmU4nYnkyQ9wclSkqSyts1nwFHX2nlpu0z+NwH4L29vlVZ2tQYoTLSEOySRkllnDumDn43tD4dTxP3vfI+l3x0M6f27u0P17XCKQJpBiz7pgdecUe8lSN9yuW+eiChZxednZ0Hw/99qrRY7fvbCN3H5+ETdzcl90pGdqkeHzYntR5sSfTpERNQDhD0kWb16NWbOnIni4mIIgoAPPvjA435RFDF//nwUFxcjJSUFU6ZMwY4dOzyOsVgsuPvuu5Gfn4+0tDRcfPHFOHy457xamHoumzN4kqRdXreVpMXtdocTDul5ajkkSVrF2Skw6DSwOpw43NDmcZ+8BivYkMSg+jfsr5dE/vdvCTAEkYcj/r5O/B7vkFNYGjx5xSjc8tMyAMD8D3dg+5Hk/+WnstbdRyIEusJBRERERESd0mgEjCt1pUmYoCIiolgI+yqu2WzG6NGj8dxzz/m9/8knn8RTTz2F5557Dhs2bEBhYSGmTZuGlpYW5ZjZs2fj/fffx1tvvYW1a9eitbUVF110ERwOR+TPhKgLeCdJrH5eXZ+0xe0aJkl6Eq1GwElSOfiBE569JHL3R14npe2A59+/v0GHOyni/3u3PPQINUkiH2fQaaHRCHjkwuE4/9RC2Bwi7nlzC9qs/hMr3dXK3cdx+hNfYvRjX2D0Y1/g7je3AGAfCRERUXf3xY4afLO/zu99XZH2E0URC5bt8vsxmTYkcplQJpW3VzQk+EyIiKgnCHtIMmPGDPzhD3/A5Zdf7nOfKIpYuHAhHnnkEVx++eUYMWIEXn31VbS1teGNN94AADQ1NeGVV17BX//6V0ydOhXl5eV4/fXXsW3bNnz55ZfRPyOiOJIvFMsJC38XhzukC70mXZINSbTu4naHNPzRajkkSWZyL8n+E569JPXm0NZtCYKg9JL4G5LIt/lLmQDqJElov83LjycXxguCgD9dMRKFmSYcqDXj8Y/8d590RzVNHbj37a041mxBU7sNTe02JWU26eT8BJ8ddV/8nktElGg1TR247V+bcO0/vg3r/QQIcDWDhHBskETp17tP4MXVB8L6+ES9jVzevvFgPZx++hOJiIjCEdN9QBUVFaipqcH06dOV24xGI8466yysW7cOALBp0ybYbDaPY4qLizFixAjlGG8WiwXNzc0eb0SJICcsUqW+EX8Xfzus0rotfZKt25KL251OJkl6iJPyXb0k+72SJHUhDkkA98DCXxpEvW5L9POyRqW43eH//kCPZ1B1oWSnGvDU1aMhCMBbGw5h2bbqoI+TaE6niDn/3orGNhtG9MvEl3POwlf3ud7WPXQOrjt9QKJPkbo5/ppPRNT19h5rwb83HMKx5o6I3l+ECGeI/dFN7Taf2+Z/uAPfHnClVw7WmX3ul3FjJ5HLqcVZMOk1aGyzYZ/Xi8KIiIjCFdOruDU1NQCAgoICj9sLCgqU+2pqamAwGJCTkxPwGG8LFixAVlaW8lZSUhLL0yYKmV3uTDDIQ5LAxe3Jtm5LL63bEkV1Yia5Bj3kaVBfed2WV5JEKm7PTw9hSKILnCSRhyCi6B4g+rsfCJw28TheGjqqC+MBYOKgfPz6rEEAgIfe/QFHG9uDPlYivbTmANbtr0OKXou/XVOOk/umY1Af11txdkqiT4+IiIj8mPb0ajzw7g94+ss9Eb2/wyni7Y2HlD+H8gIRtSXrKnHNS+GlV4h6M4NOg/ISeeUWe0mIiCg6cbkC6h0fFkUxaKS4s2Pmzp2LpqYm5e3QoUN+jyOKNzk5kioNQPy9ur5DWsFlTLJ1W+rVWh021/NikiS5uZMkrR6/qLuL2zvvJAHcqQ6r3fcXffXgxN/XgnowEsrKLXcnie//Nd07bQhG989Cc4cdf/ik+67d+uFwI/7y+W4AwLyZp2BQn/QEnxERERGF4+vdJ5T/HvzIMp/7A/1a653cjSWmR4j8G1/mWrm1geXtREQUpZgOSQoLCwHAJxFy/PhxJV1SWFgIq9WKhoaGgMd4MxqNyMzM9HgjSgS7lKFPNegABEqSSJ0k+uQakuhVqRF50KPlkCSpDS3MgF4roLbVikP17vRFeOu2AidJLPYgQ5Ig93tzd5L4/l+TXqvBHy8bCQD4atfxhJS42xxOrN5zAmaL/49tttjx/97aCrtTxIwRhbh6PFOPFB75IhhLeYmI4utIYzteXnMAj320A/uOt2Dms2v9HufvRR5VdW3479YjXdqB8N+tR7vsYxElkwlSL8kGJkmIiChKMR2SlJWVobCwEMuXL1dus1qtWLVqFSZOnAgAGDt2LPR6vccx1dXV2L59u3IMUXdl90qS+O0ksSV3JwkAWKTnwCRJcjPptRjZLwsAsF716iq5uD0vhHVbhk7Wban//ftbpxVsiOL7eHInif9/d6cWZ6J/TgosdifW7K0N+nix9v6WI7hh8Xo889Vev/f/Z9NhVNSaUZRlwoLLRwZNUBIREVH8/Ovbg7jjX5v8/gwy6U8r8IdPduGf/6vE1KdWY9uRppAf97qXv8P/e2srPth6pNPjXv3mYNjnTEThKR+QDa1GwNGmDhzp5it5iYioewv7Km5rayu2bt2KrVu3AnCVtW/duhVVVVUQBAGzZ8/GE088gffffx/bt2/HjTfeiNTUVFx33XUAgKysLNx8882477778NVXX2HLli34xS9+gZEjR2Lq1KkxfXJEsSZfFO68kyQ5kyTqgYh8cZtJkuQnR9DXV7iKQO0OJxrbXGWh0Ra3B0uKqIck/r5WAj2ev3VbgGuV49ThrsThlzuPBX28WJNLVKub/Be6nmhxrTGbfkoBslODf26JiIgofn73wXZ8tqMG724+HJfH//D7+KU7GCgkCk2aUYcRxa5NI0yTEBFRNMIekmzcuBHl5eUoLy8HAMyZMwfl5eV49NFHAQAPPPAAZs+ejVmzZmHcuHE4cuQIvvjiC2RkZCiP8fTTT+PSSy/FVVddhUmTJiE1NRUfffQRtNrkuqhMvY973VYnQxKlkyS5kiSCIChDEQs7SXoMJYJe6Vpx2CANSAQByAnhQr68+spfUkT9798SZIji736f4ztZtyWbfoprSLLix+NwdOGaCwBoand97gINfJQkTJJ97VP3IX/HFXl5jIjIx9ZDjbjxn+ux73iLz31f7TqG7w81+n2/1o74rOj8evcJfHegLi6PTUShGyf9vrOevSRERBQFXbjvMGXKFI8CYG+CIGD+/PmYP39+wGNMJhOeffZZPPvss+F+eKKEche3u750/L56Xlm3lXxDP51GgMMpujtJOrlYTclhXGkuBAGoqDXjeEsHGsyuC/05qYaQkkLuTpLOi9st0r8ZNWuQYnffxxM9PqY/48tykWnSoc5sxZaqBuWXoq7Q3O66yBLouViCJGGIiIgocpf+/X8AgL3HWvG/h85Rbt9/ohU3v7oRAFD5pwu79JyufunbLv14RORr/MBcvLK2gkkSIiKKCq/kEIXBLl30lddt+Xt1vXvdVvJ9eckXpzvYSdJjZKXqMbTAleTbWNmAulbXSqhQVm0BnXeSBC9udw9OQlm3ZZMeQ9/JkEGv1eCcYX0BAMu7eOWWnCTx93UPdF48T0RERLHh3TtQVd+WoDOJH/4EThS68QNzAAB7j7eiQepeJCIiChev5FCPc7SxHb9cvB6r9pyI+WPbpfU+qfoQitt1SZgkkfon2EnSs0xQeknqUSf94hDykETbWXF7sCGJ6v5QOkmkY4xBhgxTpZVb0Q5JjjV34KZ/rsfXu4+HdLwyJAmQJAnWqUIUjCB9y+0ksEtEREREKnnpRgzqkwYA2MCVW0REFCFeyaEe58tdx7Bqzwm8/u3BmD+2fFFY7iRxOEWfXgR5VVWyrtsC3IMercAhSU8wfqB7SFIvDUnyQhyS6L0GZ2rBhiDq22whrduSkySd/7s7a0gf6LUCDtSasf9Ea9DHDeTzHTVYufsE7vv392i1BN9X3tzReZJEvt3AJAkRERHFicCcCZEP+UVhGw82JPhMiIgoWfFKDvU48sXOFumCZizZ5U4So7vOx/sV9nLpuTEJ123pNPK6Lam4XctfwnoC+ZeGXTXNqKwzAwg9SaKPUZLEEkqSxB7auqoMkx5nDMoHEF2apM3qGgbWma14ec2BoMc3s7idiIiIEkwE44ZE3tQvCiMiIooEr+RQj9NmcV34DOWV4eGyOz2TJIDvBdOkTpJovZIkXLfVIxRkmlCalwpRdA8VQk6SyJ0kfoYg6nVzQddthZMkCSGJMW149L0k8kATAP6x+gBOtFgCHiuKYujrtpgkoQjJrw7m5S8iojD0wG+aPfApEcWVPCTZfqQJbdbYXwcgIqKej1dyqMcxSz8UmS2OIEeGT74orB6AePeSKMXtSdhJIl+cllcrsbi955B/cTjc4Co7zUs3hvR+RiVJ4vvrunoFl791XOrbQilut4aRxJB7STZXNaC2NfBwozMWVbG82erAcyv2Bjy23eZQPgeBhiSWEJMwRERE1HW4PZao5+ufk4LCTBPsThFbqxoTfTpERJSEeCWHepx2aYVOS0f8kiQGrUYZIPgkSeTi9iRct+WdHNFqku85kH8TpCGJLNx1W/56OIKu2wpyv8/j2V1DiFCSGEVZKRjZLwuiCKzYFVrxujd5oDmmJBsAsPS7KhyU1pF5a253fz/xNzBy3c51W0REREREXU0QBIyXVgyvZ3k7ERFFgFdyqMcxW+V1W7HvJJEvjuq0gvvisdfFX3cnSfIlSbyTI0yS9BxyL4ks9HVb/oeBQPDOkXiu2wKAaVKaZPmuyFZuyUmSKUP74MwhfWB3ivjrF3v8Hiuv2nK9X5B1WxySEBERdZ0gP66KSbi7qrOnxOJ2Iv8mDMwBAGzgkISIiCLAKzmUdBxOEct3HkNdgBU7bVIXSYfNGdKKn3DYHfIaKg30Un+H+tXyDqeo/NmUhBdKvS9Os5Ok5yjNS0WfDPeKrdz0MJMkfjtJQi9uD2fdlvy1FczZQ129JN/sr4voa10edhh1Wjx4/lAAwIffH8X2I00+x6qHJIE+lrIujOu2KELKSphkvKJHRERElEBykmTzwcaYXwcgIqKej1dyKOl8tesYbn1tI/74yS6/95tVRW3mGJe3252uC1d6raC8Wlz9A5i64yCZi9uVP3NI0mMIguCxcivUdVsGre+/c1k467YCpS88jg8ziXFqcSZyUvVotdjxw+HGkN5HTb0a79TiLFwyphgA8Oq6Sp9jm1VDkkCpGGVdWBIOSImIiJIW58pEBGBI3wxkpejRbnNg59HmRJ8OERElGV7JoaRT09wBADjS2O73frmTBABaYz0kUdZtaZRX2MsXRgF3xwGQpEMSn04SDkl6kvFSBB0AclNDHJLoQituD5Yk8ddp4s0WZhJDoxEw8eR8AMCavbUhvY+aOkkCAGcN6QMAqG7q8DlWnSQJ9FzCKZ4nIiLqSZrabVi7txYOJycWsdDZZ1HkVIjIL41GwLhSrtwiIqLI8EoOJZ02aQiiToyomeM5JJGK2/UawW+htfzKdL1WSMoBg86rqN07WULJ7YxBroFCYaYJuhAHEaEWt6tTVO7bVOu27MF/oZcHMaF2kgDAZGlIsjaqIYnr48npmjqz1edY9ZDE4RT9XgSSh0LhnD+Rmrxui5e/iKi76rA5sKu6GaLXWsArnl+HX7zyHV7/9mCCzowC+fvKfYk+BaIuM05Kzq+v4JCEiIjCwys5lHTkIUmbxfeirOt292CktSN+SRJ/67aU9T265EuRAL5DEa2G3yJ6kqGFGfjbNWPw7HXlIb+POzHV+Tot7ySJ9yDB6vD/9erv8fRhJDEmSUOSLYca0dJhC3K0J/e6LdfXa16aq7Ol3uzbd9Ts9dh+i+zZSUJERD3cVS9+gxl/W4NPtlV73L7veCsAV7dXIlXVtfncJvSw1/yEW9z+5893x+lMiLqfCWWuJMnGgw0+w1wiIqLO8EoOJR35wmaglEibzX0xtiXGSRKblCTRad1JEpuf3gVjEq7aAnxfAc9Okp7nkjH9MF7VTRKMXKLuN0liVw9BPO/3HpoE6vGQiaLo7iQJY8hQkpuKgXmpcDhFfHsgvFeMeSdJ8qQy+3qz1eeXKnWSRP2+auF2qhARESWbHw43AQDe2Xg4wWfi35l/XpnoUyCiBBrZLxtGnQb1Ziv2n2hN9OkQEVES4ZUcSjpt0pqtQKXs6oRJzIvb5XVAGg0M0sVjv0kSfXJ+aXmvCEvGlWEUW/4SU7LOitu9/+yv00TNrkqdhJvE+OlgeeXWCY/bq+racP0r32H5zmN+388ifb0a9Z7rtmwOEc1eKTTvIUlnnw8mSShS8quD+cJHIiIiovAZdBqMKckGAKyvaEjsyRARUVLhlRxKOu1W14VIs9UBp1cvgNXu9HhFe6zXbdmUdVuqThI/xe3GJH0lud5r3RaTJOTv37nM2klxu8VrvZa/5IWaeuig14X37+6nJ7sK19fs8+wlefzjHViztxZvfOd/P7p8TvK6LZNeizSD67/rvXpJmr2GJJ0V1TNJQkREvRXX28RGZz8JbanihV+izkwoc6XmWd5ORETh4JUcSjrtNvfgQ71aCwDarZ5/jltxe4B1Wx12z46DZONd3M4kCRn8/DuXqQeSliDrtvy9v8f9qiFMuMXnZwzKg0YADpww42hjOwBXWeOXu44DANpt/vtQlCSJaqiRq6zc8uwlaW73/F7i/fycTlFJw3gPG4mIiHoajkIS54sACVkicpFXC3NIQkRE4eCQhJJOm2oQ0uY1BGmzef65JV7F7RqNUi6tvlhqsSX5kMSnuJ0Xe3s7fYB1W6IodlrcHm4niZw8EYTwE0xZKXqMlmL1a/fVQhRF/OnTXcr97Tb/H9vdSeL+es2VytvrWj2TJMHWbak/F0ySUMSkf/p8JTYRUe8177/bsWrPieAHEpFfp5XmQCMAhxvaUd3UnujTISKiJMErOZR01GkR76SI2eLw+nOs1225i9v9d5LI63uS80vL++I0hyQk/zv3HnI4nKJHb4L3Oq1gRe7e5FV2eq0GghD+v7vJJ8u9JLX4YucxbK5qdJ9bgCSJvw6hvDR3ebtasOJ2DkmIiIiYMImFV785iJW7OSQhilS6UYdTijMBuNLlREREoeCVHEo66tU53kMRudRdFvt1W+4LuX7XbckXXXXJmiTx/JbgvX6Leh9//85df/buA3J4/TncdVvRlZ5PkoYk/9tXiyc/+xEAcLq0j7gj0LotP0kSeUhS591J0uEaksjzG58kier56vl1Q0REPVx3SryJHM0QkReu3CIionDxSg4lnXCSJC0xHJKIogiHU163JSivFrc61MXtyb1uS88kCXlRitt9hiLhrdfyTpZ4k4cOkaYwygfkINWgRZ3Ziv0nzMhO1WP21CEA/HeS2B1OZejpr5NEvW7L5nAqa/5yU133BxoC6bUCNPy6oSjxch8RERFR5CbIQ5KKhgSfCRERJQtdok+AKFzqThLvdVrtXp0krTHsJFG/cl4XKEkivzI9Wddt+SRJeLG3tzME6CTxWacVZL2W93oqb/L9kZaeG3Qa/OSkPKz40VXWftfZJ6NPhqtfpMNPJ4n6fNRDTfe6LXdxu3rVVm6aAXVma8DnG2kShghQKkmIiJJWdwiYzPvvdo//75dfFEFEvcc4aUiy+1gLGtusyJZe6ERERBQIr+ZQ0lGvzjFbu66TxO5UrdPRCu4hiUdxu9xJkpxJEp9OkggvWFPPEWjdVtChiM96rtCSJPoohgyTB7tWbvXLTsH1Z5QqXSP+1m2phyTq9IpS3K5at9UsDUkyjDqkGLQe5yuTn7+efSRERERdSvAaMb/6zUG8vfGQ8uc3vqtS/ru5w4apT63qsnMjosTok2HESflpAICNlUyTEBFRcEySUNLxTJL47yQx6DSw2p0x7STxSJJoNP6L2+3J3kni+UsmkyRk8DMM9PfncNdveZO/vqJJYlw7YQCOt1hw4cgiGHVapEjDSovdCadT9FiDZZG+VvVawWOtnL/idjlJkpmid68fC7BOjEkSioXu8EpsIqJkEayTpKq+Tfnv19ZVYt/x1nifEhF1A+MH5uJArRkbDtZj6ikFiT4dIiLq5jgkoaTidIpexe2eQxB5gFKQacSh+na0xHDdlt3hP0nir5MkaddteRVOs5OE9DrXvwHv5Ih3ksJ7nVb4Q5LoOkkAV4LrwfOHefxZfX5yCgRwr+DyHmjmpQcekmSl6JUhSKDnG835EwkCv+cSEYVifUU91u49gWdW7Avr/Z7/en+czoiIupvxZbl4e+MhbKhgeTsREQXHIQklFe8Lk95JEXlI0jfDhEP17TFNksj7jLUaAYIgKGt1PJIkAS68JgvvPgjvoQn1PoGSE8GGIvL9aQYtzFZH0HVbyrqqGCYx1EOSdpvDY0giJ0m8B5q5ae7idlEUIQiCKkmiU3W0eL5qNRZJGCIiomQXjyDcvuOtuP6V7zxuu+rFbyJ6LLPVdwUnEfVM4wfmAAC2HWlCh82RtCuxiYioa/BqDiWVNp8OEv9/7isVNpstdogx2lsiX+SVV1D5u3hskZIkpiRNkmi9hiIMkpCybstnKBBaciTdpPN7vzer0kkSu390Wo2gnL93L4ncH2T0TpJInSRWh3tdX7OUSMvqbN0WkyRERERROdrYDqefkvVr//Etqps6EnBGRJTMBuSmom+GETaHiC1VjYk+HSIi6uZ4NYeSSrvXhU7v4nb3ui0TAFf6w/sV75GySxeJ5YuknXaSJOmrVNQXqHVSYoZ6N4OfxBTgHgoYpfu9i9qt0tdCulEakjg6H1bGorjdH2OA8vZAq/FSDO4uE3nlVrNq3ZYx0OfD4Xo8DkkoGvJ3XFaSEFGyivQnx0+3VWPin1bg7re2+Nx3osUS3UkRUa8kCALGl+UCADZUcuUWERF1jldzKKm0e0XkAxW356cbIF/fj1Uvid0pJUm0XkkSf+u2kjRJoi5qZx8JAe5/53an6PHqTjlZkqFKiqhTW/LXhTIksXe+3iJeSQx5YOk9YLXY/SdJANXKLWlIoqzbMumV8/NNkngOUYmIiHqjSIe8f//a1S3yyQ/VsTsZIur1JgzkkISIiELDqzmUVNp8hiRe67as7levpxtcF2dj1UsiXxSWezr8dRN02JI7SaJTXeDVcUhC8EwXqQeCNq8hiOs21ZDEe91WkE4Spbg9xkMGORUiDzBlFq8kjJpS3t7qmySRPx/ez8cap/On0C1atAhlZWUwmUwYO3Ys1qxZE/DY9957D9OmTUOfPn2QmZmJM844A59//nkXni0RUXKL0TZbIqK4Gi8NSTYfbIA9yO8jRETUu/FqDiUV71eD+xS3S39ONeiQJl28bY1VkkQZkngmSWx2dZJEWuGTpMXtTJKQN3UyQr1iyuI1BAE8BwfKkET6OvTuNPFmdcQniSGnuiwB1m35S33lSUmSeq8kSVZqZ0kSaV0Y120lxNtvv43Zs2fjkUcewZYtWzB58mTMmDEDVVVVfo9fvXo1pk2bhmXLlmHTpk04++yzMXPmTGzZ4rvmpSvJCchYdWkRERER9WZDCzOQYdLBbHVgV3VLok+HiIi6MV7NoaTis27Lu8hduj/VqFUu3sYsSeK1bstdaO174Thp122pkyR8RTzBMxmhHnTI/+5TDe4hiXoQIXeUyMNKh1OEw08Zq/J4cRoyRLZuy1XeXmt27UBvUiVJDFrX8d5JknglYSg0Tz31FG6++WbccsstGD58OBYuXIiSkhI8//zzfo9fuHAhHnjgAYwfPx6DBw/GE088gcGDB+Ojjz7q4jMnIupZvj/UiCON7Yk+DSIiAK4X/o0tzQEArOfKLSIi6gSv5lBSkS90yiEH704SeYiSZtApr2CP1ZDEu7hdr/Ndu5Ps67bUq5WYJCEA0GgEJWFk85MUMeo0fldQyfdnqNZxeacv1OK1rsoUcN1WJ0kS73VbHe5OEuXrPkCSxN/6Loovq9WKTZs2Yfr06R63T58+HevWrQvpMZxOJ1paWpCbmxuPUyQi6lUm/WlF2O8jRFz5HppH/7td+TmdiHoXeeXWhgoOSYiIKDBd8EOIug+5kyQ3zYjaVoufThJ53ZZWKZRutdhi8rHlHaY+67b8FLcn64VSuW8FALQChyTkotdqYHc6PAYD8r97o04Dg1YDm8PzfmVIYtK7b3M4kQL/A0SbUtwe23937iGJ97qt4MXt3uu2MlP0MPr5ugdU67a0/LrparW1tXA4HCgoKPC4vaCgADU1NSE9xl//+leYzWZcddVVAY+xWCywWCzKn5ubmyM74U7wXw8RJQsx4or2xHjtm4Pok25M9GkQ/f/27js8jvJcG/i9XV0usiQX2RaEYhDVNmBCLwYCJKRSEgwJ5MQHSACffARCiiEhJjkHYkiCCR0CGNOrKabYGNx772q2JduS1cuudne+P3bf2ZnZmd2VdrZp79916bI820ZjrTx6n3mem1LgtMpQeLskSbDw91wiItKRmSu5SbCq5jAWbj+Y6t0gjZ5gEWREYeCXHG2RpDvYWZLntCPfaW4mSV9wVJAYQyWKJMqF4dDV6ZnZSWJjJgnp0O0U8YmigFU3p0N8nueyhW3T06d4PjPlBPctfNyWyA8Kfz1RJGkWRZJuZXC7QSaJ6ITJ0ALpYKD9hTfWX4Lnzp2LmTNnYt68eSgtLTW836xZs1BcXCx/VFRUxL3PRESUPBwDRpSdThxTDKfdiuYuD/Y0daV6d4iIKE2Zvpozfvx4WCyWsI9bb70VAHDjjTeG3XbGGWeYvRtxkSQJP3tuJW5+fpV8BTGlB7HQWRIch9Pl8cGvyDnoFp0kqkwSc1rrvT71leKhTJLQ64ur0zO1SKK8Ct7OK+IpSCz8643bctiscjeG2xteRHHarPJ7RZvjoZSo4PZcZ+ROEr33qvj5crjLA79fQkewGFuUa48a3M4iSfKVlJTAZrOFdY0cPHgwrLtEa968ebjpppvw6quv4qKLLop433vuuQdtbW3yR319fdz7TkSUqcwej8ULu4koUVx2G04eMwQAR24REZEx01dzVq5ciYaGBvljwYIFAIAf/vCH8n0uvfRS1X3mz59v9m7ExePzo73XC69fQjuLJGlFjNsSnSQA0B1c/JQkSb5dnUlizr+hKIZEHrdlnHOQCZRh7ewkIUH+Xvcqg9sDnzvtik4Sg8wSucgSKZMkQUWGHJ0CTuDvkTpJAj9fDnd50OH2Qgp+2cW5Dt2vVfl3s4s8FJ3T6cTEiRPl8w1hwYIFOPPMMw0fN3fuXNx44414+eWXcfnll0d9HZfLhaKiItVHokiZNcWGiLJQpo3bIqLsNrkyEN6+sqYlxXtCRETpyvTVnBEjRqC8vFz+eP/993HkkUfi3HPPle/jcrlU90m3oFRlwC8D/tKL6CQZmudUhLcHrvL2+PzwBrtK8lyKTBKTxm15/cFMkuAiqHax1Kt4/RydnINM4FAURuwsklBQpCKIctyWuy/8dqdBsLtWwsZtBQuWPR7NuC2RSaIX3B4ct9XU6ZYL5TmOQMeM0bitPnaSpNSMGTPw1FNP4ZlnnsHWrVtx5513oq6uDtOnTwcQ6AKZNm2afP+5c+di2rRpeOihh3DGGWegsbERjY2NaGtrS9WXACB8ZBgREZmHP2Ip0R577DFUVlYiJycHEydOxOLFi2N63Ndffw273Y6TTz45sTuYxeTw9hp2khARkb6EruZ4PB68+OKL+NnPfqb6xX/hwoUoLS3F0UcfjZ///Oc4eDBy9ofb7UZ7e7vqI5HEFcaAumBCqScWOvOcNuQHO0VEkaRbMVYrzxG6vcNtUpFEHgdkUf0pFnd7FYummTpuS51JwsVeCtDrmtIGtwP6mSWqTpMYMkmcJo95yzEYtyXnB0UIbnd7/Who6wUAFAUD6PVGjwGhr9fFTpKUuPrqqzF79mzcf//9OPnkk/Hll19i/vz5GDduHACgoaEBdXV18v3//e9/w+v14tZbb8XIkSPlj9tvvz1VXwIRERFlsHnz5uGOO+7Avffei7Vr1+Lss8/GZZddpjr/0NPW1oZp06bhwgsvTNKeZqdTxw2FxQLUHe7GgfbeVO8OERGloYSu5rz99ttobW3FjTfeKG+77LLL8NJLL+Hzzz/HQw89hJUrV+KCCy6A2+02fJ5kh6Uqr4bu9bKTJJ2IIkmu0yaP0+oKFkfE2C2n3Qq7zaq43axOEjFuSx3cLkYQKRdh9Ub4ZALluC12kpCg1z3hUWT06BVBxHgrp81mOKJKKVHB56IIov1ZHqmTJM9pk9/D1U2dAAKjtoDQe1v7tSSqE4Zid8stt6CmpgZutxurV6/GOeecI9/23HPPYeHChfLfFy5cCEmSwj6ee+655O+4Do6xIaJsk5yzTp7bUuI8/PDDuOmmm3DzzTdjwoQJmD17NioqKjBnzpyIj/vFL36B6667DlOmTEnSnmanohwHJpQHRqWuYC4JERHpSOhqztNPP43LLrsMo0aNkrddffXVuPzyy1FVVYUrr7wSH374IXbs2IEPPvjA8HmSHZaqXOzWjmih1BKFkDyHDXnBK8Q75U6SwJ/5we3yuC3TOkk0we2aK8rdinE71gwtMCiD25lJQoJT0zUF6I/b0i2S2K2GI6qUlM9nJtHV1ePRZpKITpjwThKLxSKP3Kpu6gYQKpIYfS1ujtsiE/CnLhFlCrOzk1gapkzm8XiwevVqTJ06VbV96tSpWLJkieHjnn32WezevRt//OMfY3qdZE/YGGxOq+TILSIiMpaw1Zza2lp8+umnuPnmmyPeb+TIkRg3bhx27txpeJ9khqUCzCRJZ/qdJIEiSJc8iiuwXQ5uNymTpM+gk0RcUS6+VzK1iwQIfW2Bz7lcRwGRxm057VZFd0Xo56Uyk8Sp83itRHVi5AY7RbSdJOL9mqPTSQIAwwsC4e2ik6QoWCQJjRZTL+ckqshDREREROmtqakJPp8PZWVlqu1lZWVobGzUfczOnTtx991346WXXoLdbo/pdZI9YWOwEbkk7CQhIiI9CVvNefbZZ1FaWorLL7884v2am5tRX1+PkSNHJmpX+k25mNYb4cpnSr5QkcQeyiTxqDtJRIeJ+ZkkIrjdIJNEXnTNzDwSIPS1AewkoZDQuKxQYUBZFHDpdJJ4gj9HnQa3a/UFn9uZoE4Sd1gmiXEnCRDKJalu6gIQ6iQxylfpS9C4MCIAWLanGbe9vAYHOzhDm4gGJ5510mCgzGEFAEmSwrYBgM/nw3XXXYf77rsPRx99dMzPn+wJG4PN5MqhAIDtBzrQ1tOX4r0hIqJ0E9slC/3k9/vx7LPP4oYbblBdFdHZ2YmZM2fi+9//PkaOHImamhr89re/RUlJCb773e8mYlcGRNk9wk6S9CLGbeU6lMHtwUwS0UniUneSmJZJIge3BxZBnZqxO6IDyejK9Eyg7B6xmxygTZkrlL9jENyuVyTx9W/cVqKKDPK4LYPgdqPOLzFuq6bZaNyW+vk8HLdFZgj+2NWOsbnmiWUAAt9nT0yblOSdIiIKZ/a4LS2/X8La+lZMGFmY2BciMkFJSQlsNltY18jBgwfDuksAoKOjA6tWrcLatWtx2223AQisoUiSBLvdjk8++QQXXHBB2ONcLhdcLldivogsUFqYg/HD81DT3I01tS04/9jSVO8SERGlkYQUST799FPU1dXhZz/7mWq7zWbDxo0b8cILL6C1tRUjR47E+eefj3nz5qGwMH1OgJXjtrRXH1Nq9cojtfTGbRlkkpg2bivYSWIVnSSBxVC/BPj8kvy9kmNwZXomUI4Kslm52EsBeuO2PIrxWKJg6FZ1kugUUSKM23InOJNE+XNd+Xejzi/RSSK+jqLgz5NQFpFm3JYo8nDcFiXQ3paeVO8CEZGpapu7sOdQV9j2/yyrxR/f3YxJ44amYK+I+sfpdGLixIlYsGCB6uLPBQsW4Dvf+U7Y/YuKirBx40bVtsceewyff/45Xn/9dVRWViZ8n7PV5PHDUNPcjRU1h1kkISIilYQUSaZOnQpJ5/Ki3NxcfPzxx4l4SVOpgttZJEkr3X2BgkeOXnC7ooACKDpJPD74/FLc46NEJ4lddJIorhjv8/nlMW2DZdwWM0lIcNoD3wseVXB7qLNKvBf0iiROg04TrVAmibnfd6KzS9sVGK2TZFiBU/X3sEwS7bit4PFgJwkREVHszv3fhbrb566oAwCsqm0x7bXEcxIlwowZM3D99ddj0qRJmDJlCp544gnU1dVh+vTpAAKjsvbt24cXXngBVqsVVVVVqseXlpYiJycnbDuZa/L4YXht9V6sZC4JERFpJKRIkumUC33aq48ptXoidJJ0a4Pbc0Lf3l0eL4pyHHG9tleziKu84t3j8w+KcVvKQhIzSUjQG5elHI+lO27LG+qskB8fS3B70sZtBTtdjILb89VFEm0miTaE3s1OEjKBJThvy2iKTYKn2xAREdEAXX311Whubsb999+PhoYGVFVVYf78+Rg3bhwAoKGhAXV1LNSl2uTKQHj7hr1t6O3zZfQFjkREZC6u5uhgJkn6UhZJjILb812BEx2X3SYXNJQjt7o9Xjz3dTX2t/ZvbEmfP9hJEhxDpbzivc/rHxTB7Q7FiC12kpDgtIWPmAoFt1vgtAW+5z0647iURZS+SJ0kwU4Ml8lFhlw5uF07bkt0kui/X4fnq+c9Rwtul48HO0mIiIjiJi5+Isokt9xyC2pqauB2u7F69Wqcc8458m3PPfccFi5caPjYmTNnYt26dYnfySw3fngeSgpc8Pj8WF/fmurdISKiNMLVHB3qIgk7SdKFJEm6we2dweD2Lk0nCaAf3v766r2Y+d4WPPrZzn69vraTxGKxyJ/3+ST5e8Vo0TUTKMdtWVkkoSCHTvdEpOB2v1+SCypOu1UufETqJPEkuJMkfNxW5M4vo3Fb4j3v1nwtfewkISIiMk3d4e5U7wIRDUIWiwWnVQayjlbWcOQWERGFcDVHh2rclpdXMaULt9cPEXWT67ShINgx0i2P2wr8KTJJgNDIrQ5FkWR7YwcA4GCHu1+v3ydnkoSKB8pAa7ecSZK5byvlCDF2kpDgjBLc7tIUSZTFEJfdqnifGA8L8iQsuD3wfGHjtqIUNWMZt6XM3lJmsBDFSyfWLbidA7eIiIiI4jF5fGDk1ooa8zKPiIgo83E1RwfHbaWnHkXbvbqTRD+TBAAKXIGFTeW4rZrmrrBtsfD6A4ugdsVIKmXWwmDoJGEmCekR3RO6mSN2ZXB74D2oLJKob09+cHuuopNELDBLkiQXwI0ySYYZFElcwdFikgR4/aEFa3aSkBks/LFLRBlCYkoSEWUoUSRZU9sCn58/y4iIKICrOTpYJElP4kpwp80Ku82KfKcmk8SjziQBIHebdCo6SWqaAu377b19/Xp9b/AqeIdBJ0kokyRz31bK7hF2kpCgF7zeF6mTRFEMUQW3x1AkcZncieEKFkn8UqiTpc8nyVfqGxU1C1x2VcFDHrdlD70vjIpGRERERESUniaMLEKBy45OtxdbG9pTvTtERJQmuJqjQ5lDwkyS9CE6RXKD47Tk4HaRSeI2ziQRRZLePh/2t/WotsUqNG4r9LZxKq6w7/VmfnC7xWKRiyM2K388UIAjyrgtOZPEpy6SOG1WWCwW1YgqI4ketwWECq1uxRhFo6KMxWLB8GAuic1qQX7w546ycKI6Ht7EdMJQduIV2kSUzfYc6kz1LhDRIGazWnDqOOaSEBGRGldBdbCTJD2JcVtifE6+pktEP5NEPW6r/nC3fAV5x4DHbYUWQZWLvyLjIJM7SYBQ5go7SUiQv8+9ivFSwc9ddqtcONB2kojHaYPd9fTJnVrmvn+cNivEt7I7+PNcWfyO1LkiRm4V5zpgCc5BsiueT9VJ4mMnCcWPP3WJKFMkMiLpgocWJe7JiYgAnDaeRRIiIlLjao6OXmVwO4skaUNcBS6KIKJLpDssk0Q5bkvdSVLd1CXf1un29isE16uziBsaIySFxm1lcCYJEMpcYSYJCdGC27WZI25tkUQn00RJkiTV85nJYrHI3V2iOCI6SVx2q1z80COKJEU5dtV2sY/i61TuP4skRERE+l5dVY/xd3+A8/73C6ypa+nXeTgRkZnk8PZq/iwiIqIArubocKs6SThuK12ITpEch2bclscHv1+SiyRiOxCeSSJC2wHA55fkwkssxAKxPWomSYYXSdhJQhpihJRbmUmiE9we1kliU3eSGI3bUgagJ6LIIN6ToXFbftV2I8MVnSRK2q/H6w9lnDC4nczA39WJKN0trz6MV1fV9+sxd72+AQBQ09yN7z22BPe9tyURu0ZEFNVJFUPgtFnR1OlGTXN3qneHiIjSAFdzdLCTJD31ajpJ8hXZI919PnQFCyG5DmUnSXDcltxJoj4B6uzHyC2xkKssHjjsyiLJIBm3JTpJmK1AQfL3uc54KYfNIoefi+KDxxd4r4Y6SYKdFwZFEm3Qu9ly5U4Sn+rPaCHxw/JdAEKh7YJLk8GiLP6wk4TiEaGxiYgo7Yiihx6fX8LC7Qex+1AnXl1ZjwseWhh2n+eW1CRu54iIIshx2HDimGIAHLlFREQB9uh3yT7MJElP2uD2HEcgG8AvAV1ur5xZouokCY7JEcWQWkUnCQC093pRWhTb68udJIpAczFGqM8XCm53ZXgniYOdJKShDW5XjZeyhXeSaMdtOaJkkiiLDIkIPncFC5e9mk4SV5SCpghu13aSyMcjmMuS6CIPERFRpnlpeS3+8M7mVO8GEZGhyZXDsKq2BSurD+NHkypSvTtERJRiXM3RoRq3FSFomMzh90v4bOsBHGzvjXi/bk1wu8VikQsinW4vuoLjuPIVmSSFmkySmiZ1kURsj4XIJNEbt+XxSYrg9swukogsEpuVPx4owCV3TAXeAz7leCllcLvPYNyWTqaJknic1RIIRjebyAmSx22J92qU/KArThyJc44egetOH6vaLheFgh0z4uu1WJjlQ0REBADzNzakeheIiCKazPB2IiJS4CqoDmUOCTtJEm/pnmbc9Pwq/P6dTRHvpx23BYSC2Q93eSBiDfIUnSRyEaXXi94+H/a3BQoxpYWBMTodvX0x76fXHx4sHbqiXNFJkuHjdsTXxE4SEhzaIoiq8yNCJokYtxWlk0RsNzu0XRDdZ+Jne6jrK/LrjRuejxd+dhrOPLJEtV0b3K7sqokUBE8UjQWRv3+YVUJEqXTry2t0t7f1xH4+TUSULiaOGwaLJZCTdLAj8gWbREQ0+GX2am6CiAU0ILAwL3FVIqH2tfYAABraYuwkURRJRBHkUIdb3qbKJMkJdZLUBgPZinLsGDssL7C9H5kk4ip6VSaJYvG4d5B0ktjlThIu9lKAdtyWGDMFBAogLm2RxKcpktiijduSVPczm8gJcnvVnSSuKJ0kRkKdMepxW8wjISKiwcrt9eGDDeHdIXe9vh4n3fdJCvaIiCg+xbkOHFNWCABYWd2S4r0hIqJU44qODmX3iF9SXzVN5hOB66IIYkSMysl1hHeKiFFdOQ6ranG/QDFuqzo4amt8ST4Kg8WTjn4Ft4df7e5SBLeLMW05Gb5QamcnCWmInBBtEQQIfJ847frjtlyaThKjcVtiuyNB7x153JZHZJIE36tROkmMhHXOKDpJiIiIssmrq/ameheIiAbstMphADhyi4iIWCTRpRy3pfd3MpcojnRHyQcRC5zKcVsif+RgsJMk32lXPaZQ1UkSLJIMz0dBTiCIuSPuTJLQ4rEorrGThAYbbaaIdrxUWCeJJpNEO55KS3t/s+XI47bM7SQR+y06a9hJQmZhBysRERFR4k0eHyiSrKhmkYSIKNtxRUeH26vuaHAzlyShRHh6V7ROkgjjtkSRJM+lXvRUZpLUNOt1ksQ+Q1ksENsVgeYOxdidXu8gGbdlY5GE1Jya4PY+g8wR8bMzbNxWlE4Sj9xJkpjvOdFJIt6j7jjzg7RfjwhwT1SmCmWPaJE2Elg8IaLMEC1jiYgoHYgiybbGdrT3Y22AiIgGH67oaEiSxE6SJOuWx21F7urolsdthQe3i0ySPIe6k0Tc7vH5seNAJwBg/PA8FCqKJ7HyBpPhHcpOEsViaaiTJLPfVg4rx22RmsOmP15KvBeUGR1+v2Qc3G40bivBwe3iPRkatxVfQTM8qJ6dJERENLixwY2IBqPy4hxUDMuFXwLW1DKXhIgom3FFR0M5DkYs/PV62UmSSJ3uwPHt80mGwc4A0BMsoqg7SQKfHzLoJBFFEgDYsr8dQByZJPK4rdDbRjl2Z9CM25I7SfjjgQK0we1GRRAgUAhxa8ZnpTq4XRRWxc9y8V4daCeJPGZPZ/wYkRmMFiN5ZTYRERGRuUQ3CXNJiIiyG1d0NNyKrpHivEBuRS/HbSWUsoMkUjeJCG7PizBuS5tJYrNa5PuLx1cOz1cFuscqNG4rPJOk2+NDsNFEHu2TqcSYLXaSkOC06xcFRPFEWySRg9sd2nFb+iu/fZrxXGYThUvx892tCZbvL2fwPa7NYElU8DxlD47bIiIiIkqu00SRpJqdJERE2YwrOhriSmOrBfJIpp4oWRkUH2WhIlIuiQh4V3ZqiKJIc1egSKLsMhGU3STFuQ4MzXeiMBjc3p+5o6FxW+GZJJ3u0PO4Mnzc1hlHDEe+04aq0cWp3hVKE3IniRxUrukkUbwnPF6/orPCprrdqJPEnWnjtsTXE/w6RZHHxU4Soqz25Y5DuP7p5ag/3J3qXSEiIqIYTa4MFEnW7W0Ny6clIqLswRUdDeXIJJdDHfZLidGtKIx0R+jsEAucep0kYjRJfpQiyfjheYFtOf3vJPGKThJlJklwUVQ5tmugV6eni1vP/wbW/3EqjhtVlOpdoTThsKk7QbTjsSwWi6oQIjo2RBHFYY9cJOnTZJyYLcfkcVuis6bPqz9+jChe7BfJTNOeWYHFO5vwP6+tT/WuEBERUYyOKMlHSYETHq8fG/a2pXp3iIgoRbiioyFC2nMcNuQGrz7muK3E6oqxk0Rv3FaBJoMkz6UetwWECiJAII8EwMAySUQniSKrQyyKiudx2a2wRJuXkgHsvCKeFJTB65IkweMLvBeVnR+i4OD2+uXbtZ0m4vFafb5Ed5IER+6JTpI+MQ7MnE4SedxWgoo8lE0ifw8xODkzNAVHgBIREVH6s1gsmDQu0E2yopq5JERE2YoroRpyJ4ndGrr6mEWShOpSZpJE6OzQHbelKYpE7yQJFklcgXFbnQMKbg8tYonFUjG2K9ND24n0KIsXXr8EjzfYSWIPLxh6vIpMEp1gd71cEnlcVYIzSURXoGijH3gnibozxpPgTBUiIiIiIkocMXJrFcPbiYiyFld0NJTjtrRhv5QYXe5QESpSJ0mvPG4rVPTQFklynTqdJIr7VIZ1ksSeSdLn1xu3ZQk+T6DYkpPheSREeowyR5SdE3pFEvE41eN94T9PPQnOJMnVFLx74+wkcRh0kohAd6J4sWOEiIiIKHkmjx8KAFhV2wKfnydiRETZiCu6GiLQ1+WwhcJ+2UmSUMpckG6PfmeHJEnoDv475DqU47b610kyTpNJ0uXxxXQS5PNL8qKVctyWQx63xU4SGryUxZA+n18R3B76fg+N5PKFdVaoOkl0ckk8we6SRAe3iyJJojpJOG6L4hVtWiN/Zc8M/Hciiv7zjIgonRw3sgj5Ths6er3Y3tiR6t0hIqIUYJFEI9RJYkWOneO2Eq3P51eFOSu7StT3k+RiRq6iEJLn7F8mibaTBIgtvL1PcfW7XnB7u+gk4ZXkNAjZrBZ5scPj88vvB6fO6Dm3spMkWEywWS2wKh6vlaxMklCRxK/a3l8Om7pI0udN7LgwIiIiIiJKHLvNilPHBbpJVnLkFhFRVuKKjoaYWZ9jtyHHKRbWOG4rUbo1RRGjTpIexRgudXB77J0kQ/IcGJLnBAC47DZ5UTeWIolX0W2iXMh1ahZLOW6LBiOLxSJ/r/f5JEXnhH4miVszbkt7u1afpqhitlCRxB/8M75OEvE4UdzROx5EpI8jLIiIiCgdTR4fDG9nkYSIKCtxRUdDXjxTdpJ42UmSKF2aoohRJ0l3X+B+dqtFtRCpzSTRdpYAoU6SccHQdsEol2RvSzd+NXctNuxtlbd5lZ0k1vBOEmGgGQdE6U4ukuh0iig/9xjdrsnxUPLodKaYSTs60R1n50dotJgmk4RFEjKJZDCwKdOn1zzwwRacdN8n2NvSnepdISIiIlIRRZKV1YchMSCOiCjrcEVHwy3GbdltYXPsyXxdmi6OaJ0kuZoiiLaTJE8nuH3csEBx5KQxxerHBosknb3q13xzzT68u34//rO0Vt7W5wudJNms4cHtAsft0GDlUHRP6HVOiO99tyLY3aiIopXoTozEjdsK/FzQ+3qJBiJaESTTf11/cnE1Ot1ezFm4O9W7klCZXswiIiLKRqeMHQKHzYKDHW7UHeYFHURE2YYrOhpiHEuOwxo2ooXM1+Xxaf6uXyTp9oSHtgOBhVll0SLfFb7oeVlVOV6bPgW/ufRY1fZQJ4n6NQ+09wIA2hUdJl5/KJjZokii1C6KMridBitREHR7/egLFgfURZDA9360TpI+vUyS4PM5ElRkED833CaN29J2xYivl+O2iJJnwZYD+HLHoVTvhq5ML2YRmaG505PqXSAi6pcchw0njA5cWLmypiXFe0NERMnGFR2NUHA7O0mSIayTxGDclvg30I7Tslgsqm16nSRWqwWTxw8LG80lulA6NPtwqMMd2K4onniDnSR2q/otox2vwyIJDVYORZEjFNyuP05LFA1csWaS6DyfmcT70uPzw+eX4u4kCX0tgZ9LfewkIZNxwkNkzZ1u/PyFVZj2zAr4NRknbT192N7YEfdrSJKE+97bjGe/rg67benuZvxnaU3cr0E0mG0/EP/7kIgo2ZQjt4iIKLtwRUdD5I8EiiTqES1kPm2RJGoniU4RRDlySy+TxEiBywEgPJPkUGegSKIMdBeLoHbNeC3tle85XCSlQcopj9tSBreH3g8uZSaJTtEgNKJKZ9xWwoPbQ8/b2+eLu5PEoQixB0L7z3F7FC9LlDlNZszH3rK/Hcv2NMf9PJE8tXgP/vXFLsPb4/0qWntC/29rn2vKrM9wyewvsb6+Na7XWL+3Dc9+XYP73tsSdtu1Ty7D79/ZjKW7E3sciYiIKLnkIgnD24mIsg5XdDTEOBaXatwWiySJoi2KdHv0j7UIXM51hH/L5quKJOFFFCNFBpkkTaJIouwkCV6pqh2no/07O0losFKOyxpQcLsm7FypT6foYqYce+h92dvnCwW3D/D96tJ0xSQ6U4XITN96dDGueWIZGtp6EvL8vX0+/PmDrfjfj7fLnZnJJM4jFvVjFJfbG37uob2IQ089A+iJiIgGlUnjhwIA9jR1peQ8hoiIUsf0FZ2ZM2fCYrGoPsrLy+XbJUnCzJkzMWrUKOTm5uK8887D5s2bzd6NAZM7Sew2ZpIkQVdwvJbIFTFalBDB7XpFEGWRRC+TxEiBTiaJJEmhcVs6nSTK/BMgfFE3R6eIQzQYOJTjtHSKAnrjtvob3J6ocVtWq0V+/W6PT96HgXZ+ab8Wj05GC1E8kjFta19LYookfkW3i17xwUi3QSdpNPF216yvb8Uxv/sIf5m/VfO8A39OMzp+iIiIKPmG5DlxTFkhAGAVu0mIiLJKQlZ0jj/+eDQ0NMgfGzdulG/729/+hocffhj//Oc/sXLlSpSXl+Piiy9GR0d6zK0NBbfb5AW03n78kk/9I4oiw/OdAIw7ScR2vU6NAkVhRHnFeDQiuF05VqvT7ZW/Bzp1MkkcmiIJM0koW4iCoMfrR1+EIoi7L1SEUL4/HLYYOkkSWGQQP8/bFeP1BtpJ4tCE0Ce6yEPZw4Lg/zEGi+xmLr2n0zL+S8trcdwfPsYrK+piur+ZPWd//WgbAOCJL/eY+KxE6UnvQgUAqG3uwm/f2oiapq4k7xERUfqZXBnoJlnBIgkRUVZJyIqO3W5HeXm5/DFixAgAgSvrZs+ejXvvvRff+973UFVVheeffx7d3d14+eWXE7Er/RYKbg+N2+oxWLin+HUFj+2IQlfw7wadJAbB7QCQH+wuyXPaYLXGvnQiMkmUi6bKltqePh+8wcVPr19kknDcFmWnaMHtYgSV2+fXHWflsqsLC0pi0SaR46pygz872roVRZI4O0nccidJ4OdTIos8lB1EJkkyChjJaHaI9TXufWsTAODuNzeqtvv8El5ZUYfdhzrVz2viaxMlUrfHi//7eDs27WtL9a7g8UW7cfTvPsRXO5vCbvv+nCV4eXkdzvu/hViyqwl+v4TDXR7VfeZvbEjWrhIRpZTIJVlV05LiPSEiomRKyIrOzp07MWrUKFRWVuKaa67Bnj2Bq/Oqq6vR2NiIqVOnyvd1uVw499xzsWTJkkTsSr+JLgKXYtyW2+CqK4qf6CQpDRZJut0GmSTB4olukcQliiSx55EAik4SRceIdu6oGAcmApqjBbczuJkGK6eiyKEXzB7qJPHrdlZECm4X769EdmKIn+ci8NlmtQy4KOPUdMUkY/8pO4j/YTJ5gd9iYp/H3BV1uPvNjbjwoUWmPWespFhKMQZ3sVgSk69EmeeRT3fin1/swhX/+Copr+f3S/j3ot1YXRt+9fODHwa6pn7zxgZ5277WHjz3dTWaOkMFkeueWo4jfjsfp/5pAR76ZLu8fcar6xO450RE6UMUSTbvb1NNnSAiosHN9BWd008/HS+88AI+/vhjPPnkk2hsbMSZZ56J5uZmNDY2AgDKyspUjykrK5Nv0+N2u9He3q76SBQxPzvHYUUug9sTTswgj7WTRK9TQ+SQ9CePBNAft3WoU10k6XAHFlRD47bUbxntouhAx/cQpTs5uN0ryRkcqkwSOfPDG7ZN+XiPL3xVUa/oYjYxiq8tWCSJp6DptAcWQOVxW/L4MS6MUnzE4rrRAr32O2zngQ5c+Y+vsGDLgX6/VqJyM2IpLsT60mvq9K/gNPOdlup6xr7WHi7ADGJbGhL3O4ued9fvx6wPt+H7c5bGdP/LH12Mme9tMbz9H5/vMmvXiIgyxqghuRg9JBd+CVhTy24SIqJsYfqK1GWXXYbvf//7OOGEE3DRRRfhgw8+AAA8//zz8n20V9hJkhTxqrtZs2ahuLhY/qioqDB7t2W9isV4EcLNIknidAY7NUoLcwAEOnl8/vDVk25PhHFbwU6S3H4WKAp1gtu1nSTitj553FaUTBJ2ktAgFTW4Pfi9r1zsc8UY3N6n83xmywn+7GjtNqFIYgs8Vyi43a/aThQvoyKCdvMv567Fxn1t+PkLqxK+TxS7WAtQ9Ye78c0HP8epf1qQ4D2ibKEdTadnX2sP3F4fHl6wQ/4/MZJtjckt9BARpYPTKgPdJCuZS0JElDUSvqKbn5+PE044ATt37kR5eTkAhHWNHDx4MKy7ROmee+5BW1ub/FFfX5+w/Q0Ft4cyScQ2Ml+3W91JAqivRBdELoxeIaQgOGZLFEtiJTJJVJ0kmiKJuM0rj9vSZJJorhxnJgkNVg5FkUM3uD343lAWHWMdtxXKJEncJd2igNnaExgpEs971aHpJOlLQicMZYf+ZpK090Rf4Ew2M8dtxfJcKZ1MFueXurw6sPBiFKZN1F+xdmld+8QyPPrZzpjuO2Mex2wRUfYRI7dWVLNIQkSULRK+ouN2u7F161aMHDkSlZWVKC8vx4IFoSvmPB4PFi1ahDPPPNPwOVwuF4qKilQfiSJ3kthtcAU7SXr6fAkbS5HtRBFiaL4TtmDouugaURLjtnIjZpIMtJNEP7gdCOWViAB3hyYYnsHtlC1EAUMd3B56P4jODFEksVstsCreL84Iwe16QfBmE+/NdjPGbckh9hL8fknOrUpkkYeygygKxHrKEU/2RWrPapL/6hv3tuG2l9egrrk7pvvztI8GszV1rTHfV6/Dm4hosDutcigAYF19qzySnYiIBjfTV6R+/etfY9GiRaiursby5cvxgx/8AO3t7bjhhhtgsVhwxx134C9/+QveeustbNq0CTfeeCPy8vJw3XXXmb0rAyIWu1wOm2rBm+HtiSEKIgUum1zk6NKZzS3up1ckqSzJBwCMH57fr9cucOmM2wrLJBHjtvSD2+1WbScJrySnwSlUGIgc3C4Kn9quClfEcVuS7mPMJLrQQuO2Bl7QVO6nR1k0YicJxSnUSRLjvK1Bzsy8kCv/+RXe39CA6S+uNu9JM+DfQ5IkPPt1NVZzpnpS7T7UiccW7tK98CdRqpu68M8v9DNE/Cx0EBH1y5EjCjAs3wm3149N+9pSvTtERJQE/ZtPFIO9e/fi2muvRVNTE0aMGIEzzjgDy5Ytw7hx4wAAd911F3p6enDLLbegpaUFp59+Oj755BMUFhaavSsDEsoksapGO7n7/OwSSABREMl32pHvtKOj16v7C6X4d9HrFjnvmBF4/5dn4RulBf167aKcwLgtt9cPj9cPp90qd5I47VZ4vP7wThLNle4WiwVOm1VeNOb3CA1WcqaIT1KMxwq9H0TRQbxntAUD0WXh0ekk0Xs+s4kCpiiSxFPQVO6nsmgUT3cKEaCY3hRzJ8nAXytRnRKx7VNsOx7LPhrnt+jfsKcpemZDrDIhcP3jzY24LxjMXfPg5Snem8Fnx4EOPPt1NX55wVEYNSRX3n7hQ4uSvi/fn7PE8Lb5mxqSuCdERJnPYrFg0rih+GTLAaysacHEccNSvUtERJRgpq/ovPLKK9i/fz88Hg/27duHN954A8cdd5x8u8ViwcyZM9HQ0IDe3l4sWrQIVVVVZu/GgCmD2x02qzwCqpctlgnRFcwfyXfZkeeKoZPEEV7Xs1gsqBpd3O8CRb4rdH+x0CGKJOOH5wW3BxZU5UwSa/jCjnLETk4cV6cTpTOHTidJpOB27eisSMHtes9nNvHzoa3HhE4SxX56gkVWILH7T9E99thjqKysRE5ODiZOnIjFixcb3rehoQHXXXcdjjnmGFitVtxxxx3J29EI+lv0iHT/VI0JTfcxVdr9iydDZfanO+Lal2QM6Nt10LyiULr6cschvLoycXmFkVz5j68wd0W9uR1KA3S4y2N4276WniTuCRHR4CBySVYyl4SIKCtwRUej16u+IliE/YriCZmryx04rvmuQCcJYJBJEmHc1kDZbVa5M6Wjtw8+v4Tm4C+YYoSXuCq+z++XH6PlUFw9znFbNFgpg9f1xkuJwoHRuC2nLfBe0+skCT1fAoPbtUWSON6rVqtF1RnDcVupN2/ePNxxxx249957sXbtWpx99tm47LLLUFdXp3t/t9uNESNG4N5778VJJ52U5L01JjJGjOoM2u1WgypJp9uLc/73C/z2rY2Gr2U40ispYnttoyJQMrJYYrlfe298nSSRXkOSJHR70r9TJR1Me2YF7npjA7Y1tif9tcU43i37k//aRESUWJMrA0WSVbUtHFtIRJQFuKKj4PeHxsiIBTXxZ28fM0nMJklSqJPEqcgk0VkU6IkwbiseylySlm4PfH4JFgswLphvIjJJRCeJXjCzU2fkENFg41QGt3uDGSI6nSRGf3cECyC6mSReEdyeuPdPjpxJEiiExvteFUUjd58/lKnCTpKUefjhh3HTTTfh5ptvxoQJEzB79mxUVFRgzpw5uvcfP348HnnkEUybNg3FxcVJ3ltj4n+YWLtAjEoF76zbh/rDPXh5uX6RKPAi/dq1MF1uL657chmeX1Kj3qdktEcoGBV74ukQSQe/emUdjvvDx9hxoCPVu5IxDrS7o99pEPH7Jew40GH486K2uUv+PNnvSyKiweD4UUXIddjQ1tOHHQf5/zER0WDHFR0FZTi7tkjSw04S0/X0+eSxF/kuO/KDBYtud/ixFldT5pqc+VGYEyqSiFFbw/KcGJLnkLcDoSvd7VadThIbO0lo8NMbt6UX3C7/XTtuS/F4LXncVkI7SQKv3xXsSounkwQIfb3Koq6DnSQp4fF4sHr1akydOlW1ferUqViyxHhGf1oSwe0ZcLHi80trsGR3M/747uaEvUY8PxEMO2W047ZSuHgc6aXfW78fAPDMV9XJ2RmKSyresn94dxOm/v1LzP50p+7tP3x8aZL3iIhocHHYrDh13BAAHLlFRJQNuKKjoBypJcZsiYU1jtsaOEmSsGRXE5o61Vf4dSmKIbmOKJ0kCRi3BQAFwfD2TneoSDKi0IXCYMFGDm4Pttfa9TpJFAujLga30yAVyhSR5M4PvUwSQRti7jLIJJEkSe7ESGSmh7bAGm/Iuij6KH+OsZMkNZqamuDz+VBWVqbaXlZWhsbGRtNex+12o729XfVhNtH9EOuCq9HYKaMxXGbSu6BByzBUPY2KQMb7OPCdTKMvz1T7W3tw/dPL8cW2g6neFQLw4rJAp9gjn+kXSQ52hM67M72ziogoVUQuyYqalhTvCRERJRpXdBREOLvdapGzJ0LjtlgkGahVtS247qnluOv1DartIqA932mD1WqJnEmSoHFbRXInSZ+qSFIQ3N4pj9sKLgrrdpIogtvZSUKDlLKTxC0HrYe+942C2vUeryQKJMr7JEKOpkii/Xt/OeQiSaioyyJJamkLBpIkxZVdoTVr1iwUFxfLHxUVFaY9t2DpZyeJ0VdnNXE99GBHL/760TbUNXerXztN1lz7W8tIVRbLYMgXuefNjVi8swk/fW5lqncl7aTJ2yEhth/owPZGjpkhoux0miK8PZ4LKIiIKP1xRUfB3afOI1F+zkySgdvaELjadvehTtV2OY8k2LWR5wp2krjVCwl9vtDMf7PHbYlMkk63F4eCnS4jClwodAXHbbmjd5KIxVKLhYukNHg5FJ0gekHl2gKhUUaJ26stkoT+Hm93RyTa/Yv3tcTjxc8Iu9UCq5kr0xSzkpIS2Gy2sK6RgwcPhnWXxOOee+5BW1ub/FFfX2/acwtyJkmsC/lxBJvH+mv+jHnrMWfhbnxvjnp0WSyvYRy8HuOLJ4B2fSMZ+7JoxyEc94eP8dePtiX+xTR2HeyMfqcYaTuC4+XVGb9IA/PhxoZ+3b+/3/eXzP6yfw+gjJMuhW+idHPy2CGwWy1obO/F3paeVO8OERElEFd0FUQniXIxTXzu9rKTZKDEyURTh/64LVEkMeokUebBmD1uS5lJ0qTXSdLbB0AZ3G6cSZJjt5l61TJROhHB7cosIVVwuyZ0XVswFO8T7bgt5d+T2UliVnC7KOpqi0KUPE6nExMnTsSCBQtU2xcsWIAzzzzTtNdxuVwoKipSfSRKrBcqGo3ViuV/Iu1rPPt1Nb754OdhHSOragMzuLUL5AN5jWjbtQyLLLE9XJe46CGZ7n8vkNsyZ+HupL92a0+fac9l5inOb17fgOP++DEa23rNe9IUSvW1xf/90pp+3Z9nq6TFC+SJ9OU57Th+dDEAYGUNc0mIiAYzruooiG4R5eJZTvDzHp0RUBSb+sOBBZcuj091HOVxW8EOEqNOEvEYawI6NQpcoYB2uZOk0KXqMAGAPr8IbtfJJJFHs/HtRIOX7nipCMHt2iKEuD183Fbg71YLYEtgJ0b4uC2TgtuDxyORBR6KbsaMGXjqqafwzDPPYOvWrbjzzjtRV1eH6dOnAwh0gUybNk31mHXr1mHdunXo7OzEoUOHsG7dOmzZsiUVuy+LtgitHfNgPG6r/++l+97bgn2tPfjzB+pjkI5ZBslYy4vnNcw8YvEWJkzdFxOfbd6qeni8frywtMa05yRj2u8jXtRDRBS708YPBcAiCRHRYGdP9Q6kE5E7ou4kYSZJvJRtqU2dblQMywMQGreV54zSSeLxyfcz+5e6QoNMksIcTXC7T4zb0ukksQf2Kd6MA6J0JhcFFO/PSMHtRn/3aIokHp3RXYlgdieJ2N+OXnaSpIOrr74azc3NuP/++9HQ0ICqqirMnz8f48aNAwA0NDSgrq5O9ZhTTjlF/nz16tV4+eWXMW7cONTU1CRz11Xk4PY4L+nVic+KmbbTIpUjs9KxQBML7b9ePP+a8V7dbeZ5E9fVE2vp7mZYLcDpRwyPeL8utzfu8bP8pyQt8bsPEYWbPH4YnlxcjRXVLJIQEQ1mPBtSEIUQVSeJKJJ4OTd5oOpbQqM7DimLJMErsEXXhghl14abiqKJ2aO2gNAvBJ1ub6hIUhDqJOny+ODzS6Hg9giZJCyS0GCm7SSxWNSdVVGLJAbjtvoijLIzk3ZBKd5OEvGzQB63xU6SlLvllltwyy236N723HPPhW1Lx/BNObi9n/fXiqWTxCj3JNbjYvQasTw8GYc+Df95wySn0JSezyU/J1frAQTOQ699chkAYNufLjU8p9zX2oNvPvg5pkQppETD405at53/jVTvAlHamhwMb999qAvNnW4ML3CleI+IiCgRuKqj0CsHt4dnkrCTZGA6evvQ2h2ah63MJRGZJKI4kq8oTCiJTBKzQ9sBdSaJatyW4mqqTrcXfSK4XefyXLE4msjQaaJUE9/noojpsFlVVyhriwRGRRNRFBFE0STRRYbw4PZ4O0mC4wE97CQh88jB7UZZHmH3N8gkiWMFNOYCzYBfIX7K105YMSRNiizaf8r/LKvFWX/9HNVNXartbT19+Pei3djfylDZTCQ6lwHA3Wd8YdZba/YCAJbuaY7r9bT/FxPxPIbI2NB8J44qLQAArKxpSfHeEBFRovBsSMEtB7frdJJE+IWFjClHbQFAU6dH/jzWTpLQuC3ziyQik6S5yyMXc0YUuuCy2+RF2063V+4kset1kgR/qXCxk4QGMYfi/QDoBbNbVIt5YUUTw04S0aWV7HFbcWaS2DTjtthJQmYIvomMujwM7h6+PYbHxhuqTqnx+7c3YW9LD/7wzibV9rvf2IBZH27DDx9fqtpuZseAOwFd1WaOVIu1C2rTvjbc8+YGHGwfHKHxRGbgz36iyCZXBrpJmEtCRDR4cVVHIZRJoiySsJMkHuFFEkUniSJrBAh1knS79TtJEjHOSnSS1ASvyHTYLCjOdahu6+z1ypkkeuO25OB2XoFFg5j43hcFY+0VhxaLRVUo0BYhRBFEu8iWrEyS8HFb8XaSaMZt8f1PJojWSRLz86TJKB2jYk+s+xfL/WItKCVT2L9fAnaxT5Pv9OWOQwAC45gSZVtjR78f88X2g/K+6UnF9+oV//gKc1fU439eW5/8F48TA9eJiFJjcjC8fRWLJEREgxZXdRTE4p1q3Jadwe3x2KvIIwE0RRK5kyRwjEWnSFdYJolXdbuZxFittp5AF0lJgUv+BbRAzivpizhuSyweM5OEBjNHWNFDp2CouI/xuC1NJ4nXOO/HTK6wcVvmdJKIsYGJ3n/KDv3PJDEYtxXD1flGrxFvHkoseMVyMoX+obSdFu9v2I8/vb8Ffn/8/yB6XRztvX346bMrMe2ZFXK3tvHexU/7fpAkKez/HKUdB/pf9MlUuw91pnoXKM2x/kYUmcgl2bS/XV7HICKiwYVFEgW5k0Qxq16EhbNIMjD1hwNXNIqruNWdJMHihzxuS7+T5HBXYETXkDyH6ftXpMgeAQKjtgQxBqyjN8q4LTm4nW8nGryiZY4A6sKD9v7iNu24LU+qxm3F+X4VX38nO0nIRKK4EWsRwWhNK6YODIMXMTPQfo8mNyMdGRWa0qdDxWD/BrB72sfc9vJaPP1VNT7e3DiA/Qo52NGLs/76BWZ/ukO1XZmzkYwMDO337i0vrcGJMz9BS5fH4BGZwe31YcnuprD/P2P12dYDmLui3uS9osGGxWuiyMYMzcOo4hz4/BLW1rWmeneIiCgBuKqjIMbIKLMlXMwkiYvoJDlhTDEAoKkjPJNEjNnKV3SSKH/RPdAeKKyUFeWYvn8ik0QYURBeJOl0e+Vf7vU7SUSRhJ0kNHhpiwB6RQ1lYcTo/h5tJ0mGjtsSX0+XIsieKF6h9fr4VqtMvTq/n/dXFhd+++bG+F47hhdPx/OzdLoiW7kvRt9VhxQXsAzEY1/sxr7WHsz+dKdqe0zfxQk8WB9uakRPnw/vrt+fsNfoj0hjxyL5zesbcN2Ty3H/+5v7/dhZH27F66v3Duh1Kbuk088tonQlcklWcOQWEdGgxFUdhVAmiXLcVjCTxGBMAEVWH8wkOaViCAB1J0l3MJNEFEdER4lfUucWiGDNRBRJCiN0kqgySfzGnSRicVfZgUQ02GiLAHpB5bGM2/L5JfgUo108Xsnw+czksFlhs4bev3GP2xKdJMErpeN9PiKg/5kkhsHtabLYZRT0PZAuDeXPDeXX9+Ky2n4/V7Kl8gJt5beCUZdQvOO2fDE8Phnfkv3N6zBhyliYLfvb8eCH23Rvu/WlNQN6zrfXBYo8Ly6r6/dj/71oT8SRY0REFDsxcmtlNYskRESDEVd1FOROErsyuJ3jtuIhOklODhZJlFcrdmo6SZRXeivnfB7oEEWSUAHDLHlOGxTrprrjtjrdkYPbRVZKgabgQjSYaL/39To/IhVJlI9XLtj0JWncFhAqegPqn/MDwXFblAjR1ni1a9zpUgxJlB5P6NyroU0/kLy1u093eyoLE/EWuZKtd4BjnIR4vg6r5rHbGzvwP6+uR/3hbv0HDIBRcehQhzvsfj99dgWue3JZv8fOiULRtx5djMcX7da9T4fbG/fvEwM51p9uPRjXa1J24LgtouhOC3aSrK1vGfAIRCIiSl9c1VEQ3SKqTpLgwn1PGo5zSHdt3X3oCF5lffLYIQAC+R4ivFNkj+QHs0hsVotcKOlWLIw0tgWLJIXmd5JYLBa5GAJoiiTBokd7r1deyNUbt/WjSRW48czxuP6McabvH1G60HZ66BU1lIWHSBkmypFb4hcMbTB8IoiMKSD+DCHx9bm9ySvy0OAnroSPPZPEMJUk6mMNg9tNXChLRg0g3uyQboPw1WQsGCblNQw+V3pEMyarv4z+nWMpNGi/h7/9z6/wxpq9uOn5lXHtk2o/YrjPsj3NeGpxNb7YfghLdjfjoU92QJIkvLC0Bv/94mr0+fzo9njx8vI6HAxevKP1fx9vj/o6Rl0msTJ+zxPFJ12KtkTp7BsjCjAkz4HePj82729L9e4QEZHJuKqjEBq3pQhuD37uZidJv9UHu0hKCpwoL8qRryRv7gzkkoQ6SULHW3wu5vwDwEGRSVJsfpEEAApzQrkk6kySwPbAuC3jTpJRQ3Ix89vHY3xJfkL2jygdhI3P6u+4LcX9lVdeyZkkOu8tsymLOHF3ksQwfoxooGJd+I9r3JbBSwyk6LCtsb0/LzEghgHrcb7IqtqW+J4gzanHbSk/D/2lJwnnuLEuwIrC844DnQncm3DXPLEMD8zfKv/9n1/swnsbGvCHdzbjw02NeGfdftz37hb89q2NuPrfy3Sf459f7Ir6Om+uYT4IEVGmslotmDRuKABgJXNJiIgGHa7qKLiD3SLKkSziamOO2+q/vcE8ktFD82CxWDA8P1CAELkk3R71uC0AyAt2lXQFu0y63F50BIspicgkAdS5JLqZJO4+eCN0khBlA22nhF7nh7JQoM3osFgscpFRt0iShE4SZfdIvBki2q+f47bIDGIh2Wjh36+5IRGlxdhHRYVeXWTzaB+f7AuTdx7okD9fW5e64oe4SCSaWAoHnQadLon01c4mXDr7y5ivku1vFoj6sQN+KADjMWxKAy2kbW0IFf+63F58uvUAAKC6qQuvraof2JPGiVf7ExGllsglWVE9uC+yICLKRlzVUdDrJAllknDcVn+JPJKKobkAgJJCJ4BQkUQUQtRFEjFuK7AocDA4LzrfaVONxTKT0bitUJHEi75gJolecDtRNggPbg9/L0TqJAk8JrBNmUnikfN+kj1uy9xOEo7bIjOIUTpGa7phAcwGK6axNZLov4qp47YMdmQghZhYvqbv/Otr+fPFO5tiexED8RwHM4/huvrYFmFiKVTE2iX0k6eXY1tjBy5/9CvD+zR1ug1vk18vCePE9rfqj75S7YcJr2O1qL+f/9/rG7Bkd3zfY4Z4qklElLYmB3NJVtUeht/PMB8iosGEqzoKosVfXSQJdpJ42UnSX6KTZMzQPABASXCUVVOHBx6vX84lyHcqx22pO0nkPJIEdZEA6k6SkoLw4PaOXi+8fuYOUHbrd3C7LbwIIW5XdpJ4kpjpkaPMTImz80P7+Hg7U4iA6J0kB9qjL0wHnmfgq6zahfR4niteypFQyt0wymVQ5pkNxMa9iZkvXtPcNeDHGn2tA1mWUY/b0r/PXz+KLTPjW48sxh2vrMXn2w7E1N1g9HUk6rtLGfz+p/e34O21+7CuvjXsfre9vAY/ey56/onFYgl7L+w+NPB/14i45kYpwOB2czz22GOorKxETk4OJk6ciMWLFxve980338TFF1+MESNGoKioCFOmTMHHH3+cxL2lgagaVYwchxWt3X3YdSi5oyGJiCixuKqjEOokUY5ksaluo9iJX1DHiE6SYAHiUKdb7hQBQiO2Ap9rO0kSXyQpCGaS5Dttqq4WUSTpdHvhFZ0kVl7eR9lJOS4L0C9qROskcWjCzoHQlfFJKZIEC+AOmwW2ON/LkYLpiQZKfFcaXfGvXYyOqWMkhStfRi89kD1KRmD1T55errv97wt2YHccCyGpXHzUfs98tbMJcxbu1v032HOoE3MW7o7peQ92uPH2uv342XOrTN2/SLzaTqoI3JqLm+6Ytw5XKTqNhPc3NODzbQejPp/FkrwGj8Z24+4YnoUSpa958+bhjjvuwL333ou1a9fi7LPPxmWXXYa6ujrd+3/55Ze4+OKLMX/+fKxevRrnn38+rrzySqxduzbJe0794bRbcUpFIJdkRTVzSYiIBhOu6iiIbhGXMrjdGRq3lcqFhkwkOkkqhmk6STrd6Ape7em0WVWLi/kikyR4+4F2USQJdXiYTXSSKEdtAUCBGLfV60VfsJPEzk4SymLKwoBeULkrQiYJECokKEcGic+T0YkhiiQ5cYa2A+FFEXaZkRksoSpJ/+6v3a743LBQkYRTGjObUP747ibd7Waem7X19Oluf+Sznbjo4UWmvU5/GBbMIjxmZc1hHOrQ7zr6ydPL8dePtuGzYL6GkujijYfoAI5VrJ1Kuw524Pg/foyHPtk+kN2KW1OHRx4Bm2j/+3FqvkbKbsy7id/DDz+Mm266CTfffDMmTJiA2bNno6KiAnPmzNG9/+zZs3HXXXdh8uTJOOqoo/CXv/wFRx11FN57770k7zn1lxi5xfB2IqLBhas6Cr1ycLv+3Hrl1c8UmSRJcnBpqJNEZJJ40OUWoe3qxcq84N+7g7eL0SIJHbfl0i+SFLoCHSbKThLtyCGibKIMK9cLbnc5IneS6I7bkjtJEv/eEl2Cyv0cKO3Xx04SMkO0TJLw+xtsV9zQ3xJCMoony6ub+/2YjzeHL+onkvYwpMN1MsoCRKTd+eHjS3HGrM8AAFsU4ePKr+E/y2rDHmdUkGnt9uD3b+sXqQB1l088o8VUz6n55n7ww+1we/34x+e7Ynq82f9ef/90h7lPGIG4eGBVzWFs2d+uuo0L2UTpyePxYPXq1Zg6dapq+9SpU7FkyZKYnsPv96OjowPDhg1LxC6SiSaPD3SSrKpheDsR0WDCVR0FMVJLuYCWo1j44sit2LV098mzwUcPCRRJRBGiqcMtF0mUo7aA8E4SMXKgNAmZJMo8EiDUSdLRqwhut/ItQ9nLEaWTRNVpEiG43eNLUSZJsOjtMqGTRLu/7CQhM4QySeILVVcVSfr5XDEXaIxC2dX30r1P/eEew+f9wzubsLauJfgaBjkWcRSBUm3Xwf6N7WrpCnW3fLKlMebH+YJhsspj7Vf8o2uD7X81d62qgK1033tbdIsqemLJPUk0SZJw//tbUvPiJvBLEg529OIHjy/Ftx41zjMgovTR1NQEn8+HsrIy1faysjI0Nsb2s/uhhx5CV1cXfvSjHxnex+12o729XfVByXfq2KGwWS3Y19qDfa3G5zRERJRZuKqjoNdJYrdZ5RwKcTtFtzfYRVJa6JIXJlXjtoIjHQpc6iKJtpPkYLBIUp7AIskFx5bh6LICXHXKaNV2UTzpdHvhCY5iYycJZbOoRRB7lCJKhHFbySgy5IoiCTtJKM3FXqgwCsMObTd6LsPXiPHFE7UA/sLSWnz3scBVt7FlriRmP/RfK/4X+/FTy+TPY8lZ6XR7o94nVu+s229427vr92Puinrd26IVdmLpbjDqUqlu0u88kaRAJ4XyGWK1eX97WBEoXbT3enH3GxvQE7wYSJIk3PvWRrnzJ7AN2HmAYcBEmUj7/7IkSTGNFZw7dy5mzpyJefPmobS01PB+s2bNQnFxsfxRUVER9z5T/+W77Dh+VBEAYCVzSYiIBg2u6ii4dYLbA39neHt/iSsXxagtQJtJoj9uKzyTRIzbSlwmyXGjivDJnefikuPLVduVBZyO4CIFM0kom6mD28N/4VMWCvQyRkQhRHm1cp9XCntsosjjtszIJNH8LHDxZwOZQCykxNwxEsN9+ruuv0IzXzuTLw34+Qur0O0xr8jw69c26G6vP9yNr3fFtigvzmu0zNxPI8v2RB5z1tLtCdu2aV8bNu5ri/g45fdIf8dBvb56r+FtP3h8adTH/+uL0PitRdsPAYDcyZyuXllZjwl/+Ah9Pj8+2tSIl5arQ50lSLr/FkBshTUiSr6SkhLYbLawrpGDBw+GdZdozZs3DzfddBNeffVVXHTRRRHve88996CtrU3+qK/XL25T4k0eHxiLpj1vIiKizMVVHQUR3K7MIQn8PXCYelgkiZnoJBGh7UAok6Slu08OR83XdpI4g50kHi8kSVIEtyeuk8SIy26VF4LFIpPoKiLKRupOkfBCg3Jb5HFboVVb0Umi13littC4LTM6SdQ/Cxx2/myg+PUztz36E8H4Cv5k2z+AcRSx7Hmkr2/BlgN4anF1v18X0O8aeWON/oL+2X/7Aj9+avmAXkfY3tgR9T7anzJLdjVh+n9W40B7b0xL58ouPj1f7jgUtu2Kf3wV9Xm7DIoSyfje+3zbQfnzZ74e2L/1QMX7U/+ddfvxlU5xze8HOnv1i2YdJnYWEZF5nE4nJk6ciAULFqi2L1iwAGeeeabh4+bOnYsbb7wRL7/8Mi6//PKor+NyuVBUVKT6oNQQRRJ2khARDR726HfJDj6/JOdOhBdJ2EnSX9rQdgAYmueEzWqBzy+h/nDg9nxtJkmwaNLl9qG9xwt38Ipzbah6MlgsFhS47GjpDs0DZ+4AZTPl979eUUBVRIkxuN2d1OB2W/BPE4okmiKRXtGIqL+iZZIY3T9su+Jzw+yROEdH9ffxZz74eVyvN1CHOtx4a61xt0K6UIayx+q6YGHG4/PrLp6LkaXCh5siz8X3+gf2PTF3RV3U+2TaWLRYzFsZ3xXcHb19WF0bHvq7dE8zlhp0/Tz62c64XpOIEmfGjBm4/vrrMWnSJEyZMgVPPPEE6urqMH36dACBLpB9+/bhhRdeABAokEybNg2PPPIIzjjjDLkLJTc3F8XFxSn7Oig2Irx958FOtHR5MDTfmeI9IiKieHHFN8jtDRVAjMdtDY5MEkmS8NTiPVi8M/yKQbPsbQlcMVoxNNRJYrVaMCx48lDbHCiS5GnGbSk7SURo+5A8R1jhKllEeLtgZyYJZbGowe1RMkn0x20FO0lMGIEVjZnB7cwkoUTobyeJ0egd5fzzhgEsvsciluJLf0cvmbkfwn+W1eLOeesTvyMGNkUYVbWmLrRA/vCCHdGfzOCAGnXp/P3T5C+oG/17HO4KjI/avL8N1z25TP9OA3jeVIo2hiyaTfvasS2GDiIiygxXX301Zs+ejfvvvx8nn3wyvvzyS8yfPx/jxo0DADQ0NKCuLlRU/ve//w2v14tbb70VI0eOlD9uv/32VH0J1A/DC1w4ckQ+AGAlR24REQ0KXNUJUhZAcuz647Z6vYOjk2TD3jb8+YOt+M3r+rO1zSCKJGMURRIglEtS2xwI6tQGtyszSQ4kIbQ9mgKXQ/V3h5VvGcpe0YLbxRgrq0U/v8cVMbg98aupoiNteEH8V3pp9zcZ+0+Dn1zciL1KEnXzgx9u1b1PvGvOiV6zHn/3B3hr7T7d25S1Am2eQyy8UcZOAeZ9fdOeWWF42wtLa8O2ralrwUOfbFdt232oE79/e5NhMcRooT2WDo9EONzlwUOfbJcviAGABz4IfB9e88QyLNkdORulP6+j9cSXu2MKSY5Fogszq2u5qEY02Nxyyy2oqamB2+3G6tWrcc4558i3Pffcc1i4cKH894ULF0KSpLCP5557Lvk7TgMiRm6t0ukKJCKizMNxW0FilJbTZoVVkzshiibuQTJua2tDOwBgf1svejw+5DrNvYJbkiQ5k0Q5bgsI5ZLUBsdt5WnGbYnOkm63Vy6SlKawSFLoYicJkaAcsaU3ek4UToy6KvTGbXlEJkkSOjEuOb4Mf/vBiTjnqBFxPxc7SSgRQjWSGMdtxXAf5ftNaePeNlxyfHmMexYulgXkQx1ufLnjEM45Ovw9d/97W3BMeQGunjx2wPswUMf+/iP893lH4rYLvhF225tr9uLJxdX4wcQxuo/VFjCMbG/swDHlhboL+Uaqm7rwvceWhG3/wZwlqtGfALDnUFfMz5tMLy2vRY/Hh88UWSEAcKAjcE7XYZC1Ecn+1h5s3t8etv3ddeFFtL/M34bKknzD57rg/xbG/Lpf7UpcxzVRujmmvDDVu0CUcSaPH4ZXVtZjBXNJiIgGBa7qBIkiiV6grxjRMliC23ce7JQ/F9khZmrq9KC3zw+LBRg1RFskCVzJ3Rr8Zb9AM25LdJJ0e3w42OEGAJSlII9E4LgtopBo47bEz0+jEHbRbeFRdpJ4pbDnThSX3YYfTapAeXH8hVft12hGGDyRuAI+1ivYDTNJVMHt+v75xa7YdyyK9XvbcNfr67G+vjXstmnPrMDuQ51h25/5uhq/eWMj5izcHffr+/qZpeH1S/jH57tw9l+/CLttxqvrsbWhHX96f4vuY//xeWzHbfqLqw1vU47ZEiwW4MVl4Z0lAMIKJADQ1OmOaT+S7f0NDWEFEgDwS/qdH7E488HP5RGsSkYX+VQ3GReQ9kS4TWvTvvDCDNFgVaHp/iei6E6rDHSSbNrXhm5P/y8CICKi9GL6qs6sWbMwefJkFBYWorS0FFdddRW2b1dfdXfjjTfCYrGoPs444wyzd6VfxLgtl072RaZlkri9PvziP6vwd4P51soiiXIUgllE4aW8KCfs6uoSzZgbbSdJfrBo0uXxyiGmZansJNEUSThui7KZUxXcrtNJYhOdJPoLVxE7SZJQJDGT9mdbMoo8NPiJRlZ/rMHtRpkkiu1xjwwyKMQou13+9P4WvLpqL77zr69173vz86sMn/6vH22LeVcOd3nw9a6msO1H/nY+/vDOppifRxAXYyRCS7dxQeB7jy3B/7yqzkmxWixpmbthGknCzc+vNPspiYiIUmbM0FyUF+XA65ewrq411btDRERxMn1VZ9GiRbj11luxbNkyLFiwAF6vF1OnTkVXl/rKrUsvvRQNDQ3yx/z5883elX4ReSPa0Hbltt4M6SRZUX0YH28+gMcW7lIF0gs7D4RmV9cdNr9IIkZAjB0WfkWS6CQRtJkkomjS7Q5lkpSZcNX3QCn3z2pB2Cg2omziiBLMLgoHRl0VTlugeOLRyyTJsE4MjtuiRLAGW0BiiMyIKJZOklgZjUcyDG7X2VZv0rnGqX9agB8/tRw36OR86OV7pFJrdx8ufniR4e1vrNkbtu2Zr6sTuUsptX5vG9ZwAUmlJgEXKhENFIuORP1nsVgwOdhNsoLh7UREGc/0TJKPPvpI9fdnn30WpaWlYcFlLpcL5eUDn4VtNlEAyRkEnSTiKoY+n4SdBzpRNbpYvq2jtw8NbaGRBXXN5s+03hbMPJkwsijsNm2RJM9g3JbH55fD39Nl3JZeEDVRNlEHt4cXDKNlkohME1UniTd5we1m0naOsJOEzCDq8FKsnSQxBLfH+lyx8Pkl3DFvHapGFfWr+OLt5zisaHanaR6HlrJzl6K7962NYdtqdc5TT5z5Md6+9ZvJ2CWiQe2UsUOwNvh7ozZHkohic9r4oXhv/X6sZJGEiCjjJTy4va2tDQAwbNgw1faFCxeitLQUQ4YMwbnnnosHHngApaWlid4dQ+5gAWQwdJKsVcwE37SvTVUk0f7CnohOkm2NgU6VY3UCAEs0BY98TSeJcr50TfAX45SO21Lsn4NdJJTllIUMvaLA8aOKUVrowrk6Ic0A4Ao+pk+nkyTTxm3ZrRZYLKErLzNt/yk9iU6SmMdtJfm/pUU7DuK99fvx3vr9sPP/RDLRnkOdeGl5Xdj2788JD7Jv7/Xiv/6zGjefVZmMXSNKW1ecOBJnH1WC37wRXmCMpHrWt9DQ1ouRxTmYu6IeI4fksFueaIBEJ8ma2lb0+fy8cIqIKIMl9Ce4JEmYMWMGzjrrLFRVVcnbL7vsMrz00kv4/PPP8dBDD2HlypW44IIL4Hbrz4Z2u91ob29XfZhNjKXK0ZmlL7b16oyuSjeSJGGdskiyv011+64DgSKJKPzUJqRIEvj3OVa3k0SdSZKvySRx2q3yYmO3J3C8U1kkUY7bsvGXB8py0YLbh+U7seyeCzHz28dHfLyyk6TPF1gMzrRxVRaLRXUMGNxOZggVSWK7v1EmSaJ0uUPnQWZ3h2Q7S7IrXmlkX2sPLnhIfzRZU6d+totZI9yIjMy88rhU70JUE0YW4erJY7Hjz5fF/JhVv7sIFosFo4bkwmKx4LrTx+L8Y1J3oSJRpju6tBBFOXb09PmwZb/561RERJQ8CV3Vue2227BhwwbMnTtXtf3qq6/G5ZdfjqqqKlx55ZX48MMPsWPHDnzwwQe6zzNr1iwUFxfLHxUVFabva6/cSRJeJBHdDb2e9C+S1B/uweGu0C+UG/ep/6PeeTDQ5XHWNwJXeu893AO/iQsdhzrcaOr0wGIBji4rCLt9RIG2kyT8eCtHcFkt4YWVZCrIccif86oQynbKQoZRhkikKxHl4HZfeHB7Jr6/VEH2Gbj/lH6swW+juDtJUrje/sinO1P34ilw9xsbTHme7C2RAN988PMBPe7r3c0m7wlRiN55zq8uPCopr33LeUfGdL+bgt1U/amxMnuEyFxWqwWTxge6SThyi4gosyVsVeeXv/wl3n33XXzxxRcYM2ZMxPuOHDkS48aNw86d+r9Y33PPPWhra5M/6uvrTd/fUCaJ3ritzMkkWVvfAiBUWNja0K4abbMj2Ely7tElsFst8Pj8ONDRG/5EA7Q9OGpr/PB8OYRdaVi+U3Uir+0k0W4rKXClNAtE2Uliz7DMBCKzOaN0kkR9vD28kySUSZJ5RQZl0SjTOmEoPfV33JaRZHeYKD391eANH9fzykpzzkm3NPDq0/5we/14b/3+VO8GDWJ6P0dnXHx0v57jrkuPGdBr6120p3XVyaNiuh8RJd7kYJFkRTWLJEREmcz0VR1JknDbbbfhzTffxOeff47Kyujzgpubm1FfX4+RI0fq3u5yuVBUVKT6MJsokrh0TjbFGJVUjduSJAkfb27E6tqWqPcVo7YuP2EkClx2eLx+7D4UyiHZFcwkOXZkkRzQV9ts3sgCedSWTh4JEAg/H5oX6gzRZpIA6lySVI7aAoAiZXC7lYuglN1U47YGUBTQH7eVmZkkAIskZD4xcskf5zUZyosRItVblBdR6On2eFV//+XctfHsFhFRxkj3CXgDLaWn+9dFlIlOqxwKAFhV2wKJ7VpERBnL9FWdW2+9FS+++CJefvllFBYWorGxEY2Njejp6QEAdHZ24te//jWWLl2KmpoaLFy4EFdeeSVKSkrw3e9+1+zdiVlvcNFOb658qJMk+UUSSZLwwAdb8Yv/rMZPn10BX5TRWKJIcsrYoThuVKCYtCk4cqvT7cW+1sC/w1GlBagYlgfA3PD2rQ0itN24kKUcn6U3bitfVSRxhd2eTAWKIomDnSSU5aJlkkQjCgm6we0ZWGRQHg+GWJMZbKZ1koRIEZbSnv3auOtjX2sPjvvDx3HtBxFRpsqkdU6egRCl1gmjh8Blt+Jwl0d1gSoREWUW01el5syZg7a2Npx33nkYOXKk/DFv3jwAgM1mw8aNG/Gd73wHRx99NG644QYcffTRWLp0KQoL9bsPkiE0bksnuD1F47a8Pj/uen0DngqOrmjv9UYsaHi8fmwOhoWdXDEEJ4wuBgBs2hcIbxddJCMKXRiS58RYUSRJRCfJSON/y5JgLonFAuTqHG/lmK7SFHeSqMdtZd4iLpGZHHaL4vP+vx9cmkwSSZLk4PZMLEKKwo7Tbs3q0GUyj6i1xZ5JEv37LtJTLd7ZBACoaepSbd+8vw2vr9ob0z4QEZG+RI4+5FkHUfpw2q04uWIIAGBFdfTpH0RElJ7CZx3FKVp7YW5uLj7+OP2uTJSD2+06we3BhfyeJHaS9Pb5cPsra/Hx5gOwWS0ozLGjtbsP2xraUVmSr/uYrQ3t8Hj9GJrnwLjheagaHejm2Lw/UCTZeSDQ5XFUaSBQfdxwcztJvD4/dgYzTyZE7CQJFEnynXbdBR5ld0l5qoskqnFb/HWEsps6qLz/7wftuC1lgPtAii6pJo6HiwVUMok8bivGK5gNc9v7UbTb3tiBS2Z/qdp2+aNf4aIJZTE/BxEREVE2mzx+GJZXH8aqmsO47vSxqd4dIiIaAK7sBEUObg9scyepSOLzS/j5C6vw8eYDcNqseOzHp2LqcYHFiq3BYHQ9YtTWSRVDYLFYUDUq0EmyeX87/H4JO4OdJKJIIjpJak0qklQ3dcHj8yPfaZPzTvTIRRKdUVuAupMk1eO2Cl0O+fNMDJYmMpNyJJbL1v+wUFFU8AS7R0QXifK2TCIKO5lY4KH0FEsnifJiFGUtRHRyakW7EOKL7Qd1t3+69UDExxERUWL0d9QXu1mJUm9yZTC8vYbh7UREmYorO0Hu4JXN6TBu67OtB7B4ZxPynDY899PJuOT4cjnjY1uD/iIIECqSiFbPI0YUIMdhRbfHh+rmrlAnSVlgFNbYYYGOlHqTiiSigHNMeSGsEbouSgoDmST5Tv1GJmXxJNXjtnIcVtiCX4s9A8cBEZlJWShUjt6K1fBgHtGuAx3o6O1DnyLAPROLkKKDJBMLPJSerDF0kqyoDv3yrXwXivwxrb0tPfLn2m7fxTub8OCH2/q/o0REg5wZdYd0rF2k4S4RDQqnjh0CqyVw3tXQ1hP9AURElHa4shPkjqGTpNebnE6S55bUAACmTRmPM79RAiCU8bEthk4SUSSxWS04bqQIb28L7yQJjts63OVBR29f3Pu9Xc4jMR61BSg7SfSLJKpOksLUFkksFoucS+Kw8u1C2S3e4PaTK4bgG6UF6PL48PrqvXJou81qkYuRmUQUigZSMCLSI94H/ghVkrae0P/XyquH9yiCQrXFELfXhxeX1eI/y2rN2lUiIkoTPAshSr3CHAeOGxVYB1Fe0EJERJmDq75BogCi10nisotOkoEXSSRJgi+GIePbGzuwZHczrBbg+inj5O2ik6TucDc63d6wx7V2e1AdDF4VRRIAqAqGty+vPixfTXp0sJOkwGXH8Hyn/Lzx2tYQKOBMKDcObQeAUyqGwG614MQxxbq35zsVmSTFqS2SAKHwdnaSULYTOSQWCwZU1LBYLLjhzPEAgOeX1MjdeZkY2g6ECkXsJCGziJpHLOcLgHph7LGFuw3vN+nPn+J3b2/CH97ZHMfeERFRf2Tm2Q0RDdTk8YGRWys5couIKCNxZScoUnB7vOO2evt8uOjhRfjWI4vRHqVjQ3SRXHJ8OUYPCeV6DMt3yvkc23W6SUQXSWVJPobkOeXtIpdk/sYGAEBJgRND80O3VwRzSeqaTSiSyOO2IneSHFVWiDV/uBh/vqpK9/Y80blhs2BonkP3PslUmCOKJHy7UHYTxQCHzTrg+dffO2U0CnPsqGnuxidbGlXPm2lERotT5/8NooHo8QQuxtgSYbTmQN57Hb3hF1cQEVF6ktDPUBIiSguniSJJdUuK94SIiAYiM1emEkB0ibh0xm3lBjsbegbYSfLOun3YfagL2w904HdvbQobgyG0dnvw1tq9AIAbg1dbK8m5JDrhrKJIcoqiiwQAjh9dFHzuQHHmG8FRW4IIb4+3k6Stpw/7WgOdKsdE6SQBgKIch+FCj+gkKS3MSYsgQlEkcWTgOCAiM4migCuOoka+y45rJlcAAJ79ukb1vJnGIXeS8GcDmePLnU1R77Nxb6v8eaSAdyIiyg5p8OsSEQGYFCySbD/QgdZuT4r3hoiI+iszV6YSQC6S6HWSBBfwPF5/xDnheiRJkhcCAeDd9fvx1tp9uvd9ZWU9evv8mDCyCKdVDgu7/dhg8UGMtVKS80jGDlFtP6q0UHWVthi1JYwbbk6RRHS3jB6Si+Lc+Lo/RFaJ6JxJNY7bIgoQRQFHnEWNaVPGw2KBXFjNxNB2QNlJkpn7T+knlrGeykLKRk1Y+98X7OCIByIiE6T7WX86XEhGRGojCl2oLMkHAKyuZTcJEVGm4cpOkDxuSze4PVQ4cXv7N3Jr2Z7D2NbYgVyHDT8/uxIA8Id3NqO2uUt1P6/Pj/8sDQSq/vSb43VPfEPh7epFEUmSwkLbBafdqursOErTSVJhUieJ2KdjY+giieaso0ow5YjhcnZBqhXkBIo+HLdF2c5hUgZHxbA8XDShLOx5M42LRRIyWSz/7+1tUf5/rb5w45HPduKHjy+Fxzew8aBERJQZjCYTEFFqTR4/FACwghetEBFlHK7sBEUKbs9x2OQ25uYud7+e97kl1QCA7506GndfNgGnjR+GTrcXt7+yDn2KRYxPtx7AvtYeDMt34tsnjdJ9rtC4rQ7VifGOA51o7e6D026V76NUNTq07ShtJ4lJRZKtwe4WUciJR2lhDub+1xn4zsmj434uM4hOEo7bomyXFxyFJ/6Mx08Vi8GZWmRwKDJaiMwwLJgplh/xPWYx+Dzk+qdXmLdTRERZyIwSRLKaPfrTVcIOFKLEksPbq1kkISLKNFzZCXLLnSThCxM2qwWnjg1cEfDRpsaYn7P+cDcWbDkAIJAxYrNa8PdrTkZhjh3r6ltx60tr8LePtuFvH23Dwwt2AACuPa1Cdx8A4MgRBbBbLejo9WJ/W6+8/d31gfFdZ3+jRHex8fhgeDsQ3kkyNjhua19LD7xxXHka6iSJHNqeiRjcThRQNboYN51ViV9fckzczzXlyOE4Jli0zdQig9OkzhoiQaxddXmMx24p17d4JTERERFR+hBj0zfua4tpjCoREaUPruwEueVOEv1DctXJge6Ot9fp54noeXFZLfwScPZRJXIHx+ghuZj1vRMAAJ9sOYDHFu7GYwt3Y8eBTtisFvzkjHGGz+e0W+Xg9W0NgaKE3y/hnXX7AQDfPVW/8+KUYE5JeVEOhheocz7KCnPgtFvh9UtoUBRe+sPvl+RMkgkmdJKkmxHBY1aUE1/WClGms1kt+P0Vx+FbJ4yM+7ksFgtu/OZ4AMDQvMx8bzGThMxmU3QsbtrXpnsf5XlKH8dqERElRCr7LWKpf7MjhCg9jR2Wh9JCF/p8EtbWtaZ6d4iIqB/sqd6BdCFnkugEtwPA5SeOwn3vbcGmfe3YeaAjbGyVVrfHi7kr6gAEukiUrjhxFHr7/NiyX50tcsYRwzCyODfi8x5bXohtjR3Y1tiBCyeUYXVdC/a29KDAZVfN+Fc6flQxHrnmZIwZmhd2m9VqQcXQXOw+1IXa5m45oySSHo8Pf/1oGw60B4oqHq8f3R4fnHYrxg/Pj/r4TPOjSRXwSxK+fbL+GDQiGpirJ1VAkoBTxw1J9a4MiFkZLUSCcs1rw942VI0uDrvPHRceLX/u87OThIgoXVnSPv6diMxmsVgwuXIYPtjQgJU1hzHlyOGp3iUiIooRiyRBohXSaNTVsHwnzjtmBD7dehBvr9uH/3fJsRGf7+21+9He68W44Xk4/5jSsNt/MHEMMLH/+3nsyCJg3X5sDXaSvLU20NlyaVW54b4DiJjvMXZYHnYf6oo5l+RPH2zBy8vrwrafOLp4UI6kKs5z4BfnHpnq3SAadKxWC647fWyqd2PAyopyAAClwT+J4uXxhjpDjDqUlGWRieOH4csdhxK8V0RElG44bpEofZ02PlQkISKizMEiCQInmX+6qgq9fT4U5xqPfbnqlNGBIsna/fifi4+B1SDIe2XNYTy+aDcA4IYp4w3vNxDHlgc6WLY1dsDj9eODDQ0AgO+eMvCQ83HD8wEcQu3hrqj3/WhTI15eXgeLBZhx0dEYkh8ImbVagPN0ikFERIPV9yeORkmBk1eIkWkKXKHTMqNRWr9+bX3gQgsAp40fyiIJEVGaGuhErESWP9jbQpR4k8YH8mzX1LbA6/MPygtJiYgGIxZJEGiJvPa06FczXzShDAUuO/a19mBVbYscygUEcjk+3XoA//5yD1bXtgAAhuc78YNJY0zd1wkjA8Hoew514uPNjWjr6UNZkQtnHDHwRToxYqs+SidJY1sv7n5zAwDgv845Ar+88KgBvyYRUaZz2W2Yenx5qneDBpHhBS4U5zrQ1tOHzl6v4f1W17bg/722Hnuaol/cQEREg89AM0nYf0KUeMeWF6HQZUeH24utDR04YUz4+FQiIko/LGn3Q47DhkurAgtiygD3gx29+O5jX+O//rMaq2tb4LRZce1pFXjrlm+aHvZdWujC0DwH/BLw9wU7AARGadni6FYZFyySbN7fjh6PT/c+fr+EGa+uQ2t3H04YXYz/ufiYAb8eERGR2R577DFUVlYiJycHEydOxOLFiyPef9GiRZg4cSJycnJwxBFH4PHHH0/Snkb2nWD+VVtPn+F9vj9nCQskREQJxFx0IhooJwhy5AAAGflJREFUm9WCicFukhUcuUVElDFYJOknMdbqgw0NcHt9qD/cjR89vhTr97ah0GXH9HOPxFe/OR+zvncixg6PHoLeXxaLBceWB7tJggskV0XIG4nFSRVDkOe0oba5Gzc8swLtveELM08s3oMlu5uR67DhkWtONpyVTkRElGzz5s3DHXfcgXvvvRdr167F2Wefjcsuuwx1deH5WQBQXV2Nb33rWzj77LOxdu1a/Pa3v8WvfvUrvPHGG0ne83BDgmM/D7T3pnhP1IbnOzGi0BW2/dSxQ5K/M0REg8ARJflJf03WfoiSY/L4wNSRldUskhARZQqudPfTGUcMR1mRC209fXhqcTV+8PgS1DR3o2JYLt7/1Vm4+7JjEx7ie0wwlwQAjikrxISRhRHuHd2IQhde+NlpKMyxY0XNYVzz72U41OEGAOw80IFfv7Ye//vxdgDAfd8+HkeMKIjr9YiIiMz08MMP46abbsLNN9+MCRMmYPbs2aioqMCcOXN07//4449j7NixmD17NiZMmICbb74ZP/vZz/B///d/Sd7zcGOC3Z2vrd6L8Xd/gJufX4kz+5l7k++06W6fNG4oyopcuGhCGZzB+dgv3nQ6TqschpvOqoz4nEPznVh570Vh21/9xZR+7RsRUbY4YXTkETtGF539KIZxzcODuZBElJ7EaPaVNYchSRx0R0SUCZhJ0k82qwXfOXk0nvhyj1w4OLqsAP+56XSUJbg4IiiLIledMnrAM2mVJo0fhnn/NQXTnlmBLQ3t+NG/l+LIEQX4dOsB+T7XTK7AD03OWCEiIoqHx+PB6tWrcffdd6u2T506FUuWLNF9zNKlSzF16lTVtksuuQRPP/00+vr64HCYOyqzPyYEu0WFT7cejPqYI0ry8cS0ifjB40tx45njccdFR0OSJPz8hdUYkufAxceV4fFFu/HQj07CuOGBK5d7PD40d7kxZmgezjqqBADw9FfVhq+RFyy8vD59CuYs3I0lu5txUkUx7DYrvnVCOeZvbBzol0xElDH++v0T8Js3NgIAqkYXYdO+dtXt06aMwwtLa3Hp8eU4/YjheOL6iRhfko+pf/8y7Ll+c+mx+OlzK8O2jxmahx+fPhYvLdfvhrz0+HL86iJ1NuRplcOwovowLjm+DB9vPqD7OAAozk3d/29E2eTEMcVw2q1o7vLgnXX7UVIQ3o1LREQhwwuccg53qrBIMgBXBYskAHByxRA899PJGJKXvKt5jlUsoIjZ5WY4blQRXps+BT95ajmqm7pQ3dQFiwWYelwZpp97JE4ZO9S01yIiIjJDU1MTfD4fysrKVNvLysrQ2Ki/cN/Y2Kh7f6/Xi6amJowcOTLsMW63G263W/57e3t72H3MUDW6CDarBT5/+FWH3ztlNN5cuy9s+4IZ58JmtWDN7y6GNZhRZrFY8NQNk+T7XHJ8ueoxuU4bxjjVY0H/dFUVfv/2JgCBK5w9Xj8A4KjSAjz8o5MABC6qePrGYfD7JXlm/6zvnYgjRxTgH5/vAgD8eurR+O/zvoEzH/wMB9rdmDCyCK3dHjS09WLBnedga2MHfjV3bdjX8fQNk3DT86sMj81/nXOEfP5FRGSG0yuHId9lx5+uqsLUhxehK5jPOHpIHi6aUCoXqsXvXFdPHosLJ5Rhye5mXHJ8GeatrEdDWy/mLNyNR645GZdVjcTFx5XJo3amBn/23vft4/Gn97fAG/zZ/qerqnD+saV49RdT8M8vduGbRw7Hk4ur8ei1JwMA7vnWBMzf2ICW7sAY5IsmlOHbJ4/CMWWFqqkCwqu/mIK2nj4U5dhRec98AMDCX5+H8uIcHPv7jwAAj/34VPn/CCJKLJfdhpPGFGNlTQvumLcu1btDRJT2vnVCOR778cSU7oNFysDev/b2dhQXF6OtrQ1FRcmvMkmShD9/sBWt3X24/zvHI9+V3FqT3y/hd+9swughubj1/G+Y/vyNbb343dsbMaIwBzefXYkjOV6LiCgjpPr/x1TYv38/Ro8ejSVLlmDKlNDopwceeAD/+c9/sG3btrDHHH300fjpT3+Ke+65R9729ddf46yzzkJDQwPKy8vDHjNz5kzcd999YdsTday/3tWEf3+5B70eH2ABCl12/O0HJ2J48ErEHo8PDltgsctuM296qiRJ+GpXEyaMLEKOwwabxYJcg/FdRo+PpcO1qdMNh82KHQc6cErFENisFvlxHb198PklDMlzYm9LN0YPyYXFYoHfL2FrYzvGD8/HvtYeHF1WiB0HOvDs19W4/IRRONTZi9LCHEw5YjiautwoyXfB4/Oj2+PDBxv2Y/TQXJx/TCn+vmAHHv18F3514VF49LOdAIBHrz1Ft3Bz45nj8dGmRsz89nGoburGXz8KfD89/pNTUVlSgEtmB64OP/uoEmzY24Z5vzgDj32xG++u348zjhiGY8oK8csLj8KS3c24eEIZchxW/ODxpVhd24JvnzQK3584BieNKcaXO5vw0CfbIUnAry85Bt8+KbAg+8qKOvgkCX96fwtOHDMEf/luFVx2G6qbuvDM19UYmufEW8HCWdXoIjxz42Sc9sBnqq/hD1cchx9NrsB3//U1dh7sVN320A9PggTg16+tV21/7qeTceOzoSvcfzBxDF5fvReVJfn4yRnj8Kf3t4Qdq5+cMRYvL6/DA989Afe8uVHe/scrj8Pk8cPwry924cNNgcLlMWWFcNgtmHHx0Xjiyz1o7/HCL0nY1tiB319xHI4qLcBNz69En0/9a8rNZ1XiqWDHk81qwT2XHYtOtxc3nVWJE2Z+AgA4ckQ+qpu6MLI4F3+88jhMHDcUE//8qfwcZx9VgnsumwCLBbjskcWq5y8rcmHp3Rfi9dV7cdcbG1S3vTZ9Clq6PJjx6np0ur0AgIsmlOJHkyowakguHlu4S9VRdcWJI3HdaWPR5fHhrtfXo6W7D2OG5uI3lx6LCSOLsOdQJ77e1YTnl9aipMCJB793Ii44thRf7WrCtGdWoKTAiVPGDsUvL/gGThwzBK+sqMOTi/fg2tPG4pWV9ahu6sKj15yCypJ8LN55CFecNApb97ejKNeByeOHYs6i3fjbR9tRVuTCgXY3fvrN8bjlvG+grceDA+1utPf04b9fWqM6Lot3NoX9u9516THIc9iwYOsBfL2rWd5+ztEjsPdwN/Y0dcFhs6DPJ+GMI4ahrCgHJ4wuxnsbGrC+vlX1XPP+6wy8t2E/XlwW6JA46xsluP87x2N4gQvvrNuHP7yzGSeMLsaZRw7Hp1sP4I6LjsaeQ114fNFu5LtsKMpx4PxjS3H+MaVYv7cVH21qxIljinF0WSE27WvDG2v24pkbJ6O0MAe3vrwGFgBPTJuEPp8fY4bmojDHgbaePvx9wQ74JQlHlORj2pTxcuFAkiQ8/VU16g53475vHw8A6HR7sXhnE847ZgTynMa/88Xys0+SJBzu8sBpt6IwJ7yjQ+85Wro8GJLn6NfkgIPtvehwe+Xf4SRJgiQhaQWSbDwXSRUe6/S2cPtBPPTJDvT5/KneFSKitHfWN0rwuyuOM+W5Bvr/I4skREREg0Q2/v/o8XiQl5eH1157Dd/97nfl7bfffjvWrVuHRYsWhT3mnHPOwSmnnIJHHnlE3vbWW2/hRz/6Ebq7u3XHbel1klRUVGTVsSYiIoomG89FUoXHmoiIKNxA/39kcDsRERFlLKfTiYkTJ2LBggWq7QsWLMCZZ56p+5gpU6aE3f+TTz7BpEmTDPNIXC4XioqKVB9ERERERERElPlYJCEiIqKMNmPGDDz11FN45plnsHXrVtx5552oq6vD9OnTAQD33HMPpk2bJt9/+vTpqK2txYwZM7B161Y888wzePrpp/HrX/86VV8CEREREREREaUIg9uJiIgoo1199dVobm7G/fffj4aGBlRVVWH+/PkYN24cAKChoQF1dXXy/SsrKzF//nzceeed+Ne//oVRo0bh0Ucfxfe///1UfQlERERERERElCLMJCEiIhok+P9j8vBYExERheP/j8nDY01ERBSOmSRERERERERERERERET9wCIJERERERERERERERFlJRZJiIiIiIiIiIiIiIgoK7FIQkREREREREREREREWYlFEiIiIiIiIiIiIiIiykoskhARERERERERERERUVZikYSIiIiIiIiIiIiIiLISiyRERERERERERERERJSVWCQhIiIiIiIiIiIiIqKsxCIJERERERERERERERFlJXuqd2AgJEkCALS3t6d4T4iIiNKH+H9R/D9JicNzESIionA8F0kenosQERGFG+i5SEYWSTo6OgAAFRUVKd4TIiKi9NPR0YHi4uJU78agxnMRIiIiYzwXSTyeixARERnr77mIRcrASzz8fj/279+PwsJCWCwWU56zvb0dFRUVqK+vR1FRkSnPmU14/AaOxy4+PH7x4fGLT7odP0mS0NHRgVGjRsFq5UTNROK5SHrjsTQPj6W5eDzNw2NpHjOPJc9FkofnIumNx9I8PJbm4vE0D4+ledLhXCQjO0msVivGjBmTkOcuKiriN3YcePwGjscuPjx+8eHxi086HT9etZkcPBfJDDyW5uGxNBePp3l4LM1j1rHkuUhy8FwkM/BYmofH0lw8nubhsTRPKs9FeGkHERERERERERERERFlJRZJiIiIiIiIiIiIiIgoK7FIEuRyufDHP/4RLpcr1buSkXj8Bo7HLj48fvHh8YsPjx+Zid9P5uGxNA+Ppbl4PM3DY2keHksS+L1gHh5L8/BYmovH0zw8luZJh2OZkcHtRERERERERERERERE8WInCRERERERERERERERZSUWSYiIiIiIiIiIiIiIKCuxSEJERERERERERERERFmJRRIiIiIiIiIiIiIiIspKLJIEPfbYY6isrEROTg4mTpyIxYsXp3qX0s6sWbMwefJkFBYWorS0FFdddRW2b9+uuo8kSZg5cyZGjRqF3NxcnHfeedi8eXOK9jh9zZo1CxaLBXfccYe8jccusn379uEnP/kJhg8fjry8PJx88slYvXq1fDuPnzGv14vf/e53qKysRG5uLo444gjcf//98Pv98n14/EK+/PJLXHnllRg1ahQsFgvefvtt1e2xHCu3241f/vKXKCkpQX5+Pr797W9j7969SfwqKBPxXETNrPOOWN6PLS0tuP7661FcXIzi4mJcf/31aG1tTfSXmBIDPQfhcQwx45yEx9O885NsPJbJOleJ5bjV1dXhyiuvRH5+PkpKSvCrX/0KHo8nEV82JQHPRdR4LpIYPBeJH89FzMFzkYEblOciEkmvvPKK5HA4pCeffFLasmWLdPvtt0v5+flSbW1tqnctrVxyySXSs88+K23atElat26ddPnll0tjx46VOjs75fs8+OCDUmFhofTGG29IGzdulK6++mpp5MiRUnt7ewr3PL2sWLFCGj9+vHTiiSdKt99+u7ydx87Y4cOHpXHjxkk33nijtHz5cqm6ulr69NNPpV27dsn34fEz9uc//1kaPny49P7770vV1dXSa6+9JhUUFEizZ8+W78PjFzJ//nzp3nvvld544w0JgPTWW2+pbo/lWE2fPl0aPXq0tGDBAmnNmjXS+eefL5100kmS1+tN8ldDmYLnIuHMOu+I5f146aWXSlVVVdKSJUukJUuWSFVVVdIVV1yR1K83GeI5B+FxDDDrnITH07zzk2w8lsk6V4l23Lxer1RVVSWdf/750po1a6QFCxZIo0aNkm677baEHwMyH89FwvFcxHw8F4kfz0XMw3ORgRuM5yIskkiSdNppp0nTp09XbTv22GOlu+++O0V7lBkOHjwoAZAWLVokSZIk+f1+qby8XHrwwQfl+/T29krFxcXS448/nqrdTCsdHR3SUUcdJS1YsEA699xz5ZMCHrvIfvOb30hnnXWW4e08fpFdfvnl0s9+9jPVtu9973vST37yE0mSePwi0f5nH8uxam1tlRwOh/TKK6/I99m3b59ktVqljz76KGn7TpmF5yLRDeS8I5b345YtWyQA0rJly+T7LF26VAIgbdu2LRlfWlLEcw7C4xhixjkJj2eAGecnPJaJO1eJ5bjNnz9fslqt0r59++T7zJ07V3K5XFJbW1tCvl5KHJ6LRMdzkfjwXMQcPBcxD89FzDFYzkWyftyWx+PB6tWrMXXqVNX2qVOnYsmSJSnaq8zQ1tYGABg2bBgAoLq6Go2Njapj6XK5cO655/JYBt166624/PLLcdFFF6m289hF9u6772LSpEn44Q9/iNLSUpxyyil48skn5dt5/CI766yz8Nlnn2HHjh0AgPXr1+Orr77Ct771LQA8fv0Ry7FavXo1+vr6VPcZNWoUqqqqeDxJF89FYjOQ845Y3o9Lly5FcXExTj/9dPk+Z5xxBoqLiwfV8Y/nHITHMcSMcxIezwAzzk94LMMl87gtXboUVVVVGDVqlHyfSy65BG63WzX2hdIfz0Viw3OR+PBcxBw8FzEPz0USI1PPRez9/1IHl6amJvh8PpSVlam2l5WVobGxMUV7lf4kScKMGTNw1llnoaqqCgDk46V3LGtra5O+j+nmlVdewZo1a7By5cqw23jsItuzZw/mzJmDGTNm4Le//S1WrFiBX/3qV3C5XJg2bRqPXxS/+c1v0NbWhmOPPRY2mw0+nw8PPPAArr32WgD8/uuPWI5VY2MjnE4nhg4dGnYf/r9CenguEt1AzztieT82NjaitLQ07DVLS0sHzfGP9xyExzHEjHMSHs8AM85PeCzDJfO4NTY2hr3O0KFD4XQ6B+WxHcx4LhIdz0Xiw3MR8/BcxDw8F0mMTD0XyfoiiWCxWFR/lyQpbBuF3HbbbdiwYQO++uqrsNt4LMPV19fj9ttvxyeffIKcnBzD+/HY6fP7/Zg0aRL+8pe/AABOOeUUbN68GXPmzMG0adPk+/H46Zs3bx5efPFFvPzyyzj++OOxbt063HHHHRg1ahRuuOEG+X48frEbyLHi8aRo+B40ZvZ5h/Y+evcfLMc/kecg2XQchUSek2Tb8Uzk+Um2HUs9yTpu2XhsBzOeixjjucjA8VzEXDwXMQ/PRRIr085Fsn7cVklJCWw2W1h16eDBg2GVKAr45S9/iXfffRdffPEFxowZI28vLy8HAB5LHatXr8bBgwcxceJE2O122O12LFq0CI8++ijsdrt8fHjs9I0cORLHHXecatuECRNQV1cHgN970fy///f/cPfdd+Oaa67BCSecgOuvvx533nknZs2aBYDHrz9iOVbl5eXweDxoaWkxvA+REs9FIovnvCOW92N5eTkOHDgQ9rqHDh0aFMffjHMQHscQM85JeDwDzDg/4bEMl8zjVl5eHvY6LS0t6OvrG5THdjDjuUhkPBeJD89FzMVzEfPwXCQxMvVcJOuLJE6nExMnTsSCBQtU2xcsWIAzzzwzRXuVniRJwm233YY333wTn3/+OSorK1W3V1ZWory8XHUsPR4PFi1alPXH8sILL8TGjRuxbt06+WPSpEn48Y9/jHXr1uGII47gsYvgm9/8JrZv367atmPHDowbNw4Av/ei6e7uhtWq/nFvs9ng9/sB8Pj1RyzHauLEiXA4HKr7NDQ0YNOmTTyepIvnIvrMOO+I5f04ZcoUtLW1YcWKFfJ9li9fjra2tkFx/M04B+FxDDHjnITHM8CM8xMey3DJPG5TpkzBpk2b0NDQIN/nk08+gcvlwsSJExP6dZK5eC6ij+ci5uC5iLl4LmIenoskRsaei/Qr5n2QeuWVVySHwyE9/fTT0pYtW6Q77rhDys/Pl2pqalK9a2nlv//7v6Xi4mJp4cKFUkNDg/zR3d0t3+fBBx+UiouLpTfffFPauHGjdO2110ojR46U2tvbU7jn6encc8+Vbr/9dvnvPHbGVqxYIdntdumBBx6Qdu7cKb300ktSXl6e9OKLL8r34fEzdsMNN0ijR4+W3n//fam6ulp68803pZKSEumuu+6S78PjF9LR0SGtXbtWWrt2rQRAevjhh6W1a9dKtbW1kiTFdqymT58ujRkzRvr000+lNWvWSBdccIF00kknSV6vN1VfFqU5nouEM+u8I5b346WXXiqdeOKJ0tKlS6WlS5dKJ5xwgnTFFVck9etNpoGcg/A4Bph1TsLjad75STYey2Sdq0Q7bl6vV6qqqpIuvPBCac2aNdKnn34qjRkzRrrtttuSdzDINDwXCcdzkcThucjA8VzEPDwXGbjBeC7CIknQv/71L2ncuHGS0+mUTj31VGnRokWp3qW0A0D349lnn5Xv4/f7pT/+8Y9SeXm55HK5pHPOOUfauHFj6nY6jWlPCnjsInvvvfekqqoqyeVySccee6z0xBNPqG7n8TPW3t4u3X777dLYsWOlnJwc6YgjjpDuvfdeye12y/fh8Qv54osvdH/W3XDDDZIkxXasenp6pNtuu00aNmyYlJubK11xxRVSXV1dCr4ayiQ8F1Ez67wjlvdjc3Oz9OMf/1gqLCyUCgsLpR//+MdSS0tLEr7K1BjIOQiPY4gZ5yQ8nuadn2TjsUzWuUosx622tla6/PLLpdzcXGnYsGHSbbfdJvX29ibyy6cE4rmIGs9FEofnIvHhuYg5eC4ycIPxXMQiSZLUv94TIiIiIiIiIiIiIiKizJf1mSRERERERERERERERJSdWCQhIiIiIiIiIiIiIqKsxCIJERERERERERERERFlJRZJiIiIiIiIiIiIiIgoK7FIQkREREREREREREREWYlFEiIiIiIiIiIiIiIiykoskhARERERERERERERUVZikYSIiIiIiIiIiIiIiLISiyRERERERERERERERJSVWCQhIiIiIiIiIiIiIqKsxCIJERERERERERERERFlJRZJiIiIiIiIiIiIiIgoK/1/uqwP1yF1FY0AAAAASUVORK5CYII="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:33:17.854242300Z",
     "start_time": "2023-09-06T05:33:16.778285200Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\18213\\anaconda3\\envs\\Rainbow\\lib\\site-packages\\gymnasium\\wrappers\\record_video.py:87: UserWarning: \u001B[33mWARN: Overwriting existing videos at C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\per folder (try specifying a different `video_folder` for the `RecordVideo` wrapper if this is not desired)\u001B[0m\n",
      "  logger.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\per\\rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\per\\rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                              "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\per\\rl-video-episode-0.mp4\n",
      "score:  122.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/per\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:33:17.897997500Z",
     "start_time": "2023-09-06T05:33:17.858289100Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<IPython.core.display.HTML object>",
      "text/html": "\n        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n        </video>\n        "
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/per\\rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
